diff --git a/TBF/Rig/TestMethods/FlyingStartMassCollection/FlyingStartMassCollectionSeq.cs b/TBF/Rig/TestMethods/FlyingStartMassCollection/FlyingStartMassCollectionSeq.cs
index c1206bd20..261e8efad 100644
--- a/TBF/Rig/TestMethods/FlyingStartMassCollection/FlyingStartMassCollectionSeq.cs
+++ b/TBF/Rig/TestMethods/FlyingStartMassCollection/FlyingStartMassCollectionSeq.cs
@@ -1,26 +1,28 @@
-///
+using Common;
+using Config.Entities;
+using log4net;
+///
 /// Copyright (c) 2013-2021 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Text;
-using log4net;
-using Common;
-using Config.Entities;
-using TBF.Rig;
+using System.Xml.Serialization;
 using TBF.Boxes;
 using TBF.Resources;
-using TBF.UiBridge;
+using TBF.Rig;
 using TBF.Rig.GenericDevices;
 using TBF.Rig.RegisterReaders.PoseidonReader;
 using TBF.Rig.RegisterReaders.PoseidonReader.implementations;
 using TBF.Rig.Uni.SharedDialogs.SmartMetersCommunication.common;
+using TBF.UiBridge;
 
 namespace TBF.Rig.TestMethods.FlyingStartMassCollection
 {
-	public class FlyingStartMassCollectionSeq : Sequences.SequenceBase
+    public class FlyingStartMassCollectionSeq : Sequences.SequenceBase
     {
-		private static readonly ILog log = LogManager.GetLogger(typeof(FlyingStartMassCollectionSeq));
+        private static readonly ILog log = LogManager.GetLogger(typeof(FlyingStartMassCollectionSeq));
 
         /// <summary>
         /// Check capabilities of devces in the output path required for this test method
@@ -44,11 +46,11 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
             }
 
             if (test.Volume > devices.Scale.Capacity * Constants.TankFullFactor)
-			{
+            {
                 /// Scale capacity is not sufficient
                 message = string.Format("{0}: {1}", test.Name, Strings.Test_volume_exceeds_the_scale_capacity);
                 return false;
-			}
+            }
 
             if (!(devices.Diverter is IDiverter))
             {
@@ -75,28 +77,28 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
             return true;
         }
 
-		/// <summary>
-		/// Flying start mass collection method sequence
-		/// </summary>
-		/// <param name="test">Test entity</param>
-		/// <returns>
-		///		Event.Done . . . . . . . OK
-		///		Event.UiCmdStop  . . . . Stopped by the user using the on-screen button STOP
-		///		Event.OpArgumentError  . Target flow is out of range
-		///		Event.Error  . . . . . . Unspecified error
-		/// </returns>
-		public IList<Event> Execute(Test test, int repetitionNr, bool isLastRepetition,
+        /// <summary>
+        /// Flying start mass collection method sequence
+        /// </summary>
+        /// <param name="test">Test entity</param>
+        /// <returns>
+        ///		Event.Done . . . . . . . OK
+        ///		Event.UiCmdStop  . . . . Stopped by the user using the on-screen button STOP
+        ///		Event.OpArgumentError  . Target flow is out of range
+        ///		Event.Error  . . . . . . Unspecified error
+        /// </returns>
+        public IList<Event> Execute(Test test, int repetitionNr, bool isLastRepetition,
                                     bool isDelayedStart, Compound.CombinedTestParams compoundTestParams,
                                     HeatMeters.TestParams heatMetersTestParams, DebugMode debugLevel)
-		{
-			if (debugLevel == Common.DebugMode.Simulate)
-			{
-				return Simulate1(test, repetitionNr, isLastRepetition, compoundTestParams, heatMetersTestParams);
-			}
-			else if (debugLevel == Common.DebugMode.Inherit)
-			{
-				return Simulate2(test, repetitionNr, isLastRepetition, compoundTestParams, heatMetersTestParams);
-			}
+        {
+            if (debugLevel == Common.DebugMode.Simulate)
+            {
+                return Simulate1(test, repetitionNr, isLastRepetition, compoundTestParams, heatMetersTestParams);
+            }
+            else if (debugLevel == Common.DebugMode.Inherit)
+            {
+                return Simulate2(test, repetitionNr, isLastRepetition, compoundTestParams, heatMetersTestParams);
+            }
 
             ControlBoard.Uni.UniCB cBrd = StateMachine.ControlBoardMain as ControlBoard.Uni.UniCB;
             IScale scale = cBrd.Devices.Scale as IScale;
@@ -131,30 +133,31 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
             cBrd.SetFiltersPidShortPulses(filters, outPath.PidCoef, test.ShortPulses);
 
             IList<IOperation> readTempPressOps = new List<IOperation>();
-            if(benchPath.TempMtrUp != null) readTempPressOps.Add(benchPath.TempMtrUp.ReadTempOp(ref TempUp));
-            if(benchPath.TempMtrDown != null) readTempPressOps.Add(benchPath.TempMtrDown.ReadTempOp(ref TempDown));
-            if(outPath.TempMtrDiv != null) readTempPressOps.Add(outPath.TempMtrDiv.ReadTempOp(ref TempDiv));
-            if(benchPath.PressMtrUp != null) readTempPressOps.Add(benchPath.PressMtrUp.ReadPressureOp(ref PressUp));
-            if(benchPath.PressMtrDown != null) readTempPressOps.Add(benchPath.PressMtrDown.ReadPressureOp(ref PressDown));
-            if(benchPath.PressMtrDelta != null) readTempPressOps.Add(benchPath.PressMtrDelta.ReadPressureOp(ref PressDelta));
-            if(benchPath.ElectricMtrUp != null) readTempPressOps.Add(benchPath.ElectricMtrUp.ReadPressureOp(ref ElectricUp));
-            if(benchPath.ElectricMtrDown != null) readTempPressOps.Add(benchPath.ElectricMtrDown.ReadPressureOp(ref ElectricDown));
-            if(benchPath.ElectricMtrDelta != null) readTempPressOps.Add(benchPath.ElectricMtrDelta.ReadPressureOp(ref ElectricDelta));
-            if(heatMetersPath != null) readTempPressOps.Add(heatMetersPath.TMeterRefWarm1.ReadTempOp(ref TempRefHi1));
-            if(heatMetersPath != null) readTempPressOps.Add(heatMetersPath.TMeterRefWarm2.ReadTempOp(ref TempRefHi2));
-            if(heatMetersPath != null) readTempPressOps.Add(heatMetersPath.TMeterRefCold1.ReadTempOp(ref TempRefLo1));
-            if(heatMetersPath != null) readTempPressOps.Add(heatMetersPath.TMeterRefCold2.ReadTempOp(ref TempRefLo2));
+            if (benchPath.TempMtrUp != null) readTempPressOps.Add(benchPath.TempMtrUp.ReadTempOp(ref TempUp));
+            if (benchPath.TempMtrDown != null) readTempPressOps.Add(benchPath.TempMtrDown.ReadTempOp(ref TempDown));
+            if (outPath.TempMtrDiv != null) readTempPressOps.Add(outPath.TempMtrDiv.ReadTempOp(ref TempDiv));
+            if (benchPath.PressMtrUp != null) readTempPressOps.Add(benchPath.PressMtrUp.ReadPressureOp(ref PressUp));
+            if (benchPath.PressMtrDown != null) readTempPressOps.Add(benchPath.PressMtrDown.ReadPressureOp(ref PressDown));
+            if (benchPath.PressMtrDelta != null) readTempPressOps.Add(benchPath.PressMtrDelta.ReadPressureOp(ref PressDelta));
+            if (benchPath.ElectricMtrUp != null) readTempPressOps.Add(benchPath.ElectricMtrUp.ReadPressureOp(ref ElectricUp));
+            if (benchPath.ElectricMtrDown != null) readTempPressOps.Add(benchPath.ElectricMtrDown.ReadPressureOp(ref ElectricDown));
+            if (benchPath.ElectricMtrDelta != null) readTempPressOps.Add(benchPath.ElectricMtrDelta.ReadPressureOp(ref ElectricDelta));
+            if (heatMetersPath != null) readTempPressOps.Add(heatMetersPath.TMeterRefWarm1.ReadTempOp(ref TempRefHi1));
+            if (heatMetersPath != null) readTempPressOps.Add(heatMetersPath.TMeterRefWarm2.ReadTempOp(ref TempRefHi2));
+            if (heatMetersPath != null) readTempPressOps.Add(heatMetersPath.TMeterRefCold1.ReadTempOp(ref TempRefLo1));
+            if (heatMetersPath != null) readTempPressOps.Add(heatMetersPath.TMeterRefCold2.ReadTempOp(ref TempRefLo2));
 
             int totalPulses = Convert.ToInt32(test.Volume / outPath.FlowMeter.LtrPerPulse);
 
             ///============================================================================================
-            
+
             /// Read pressure and temperature once before calling Bridge.OnTestSelected(...)
             State.Create(string.Format("{0}({1}) : Measuring process data", test.Method, test.Name))
                  .AddOperation(checkUiOp)
                  .AddOperations(readTempPressOps)
                  .EnterState();
-            do {
+            do
+            {
                 e = StateMachine.WaitRunDevsRunOps();
                 if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
                 if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
@@ -163,8 +166,8 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
 
             /// Start the test, initialize test results
 			Bridge.OnTestSelected(this, new TestSelectedEventArgs(test, repetitionNr, inPath, benchPath, outPath, sensPath, heatMetersPath));
-			string testName = Results.Utils.GetTestName(test.Name, test.Repeats, repetitionNr);
-			TestStartTime = DateTime.Now;
+            string testName = Results.Utils.GetTestName(test.Name, test.Repeats, repetitionNr);
+            TestStartTime = DateTime.Now;
 
             //------------------------------------------------
             Bridge.OnActivity(this, Strings.Checking_tank_capacity);
@@ -189,35 +192,36 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
                      .AddOperation(cBrd.SetValvesOp(scale.DrainValve, null))
                      .AddOperations(readTempPressOps)
                      .EnterState();
-                do {
+                do
+                {
                     e = StateMachine.WaitRunDevsRunOps();
-                    if (e.Contains(Event.Error))        { retVal = Event.Error;		goto stopTest; }
-                    if (TestAndLogUiCmdStop(test, e))   { retVal = Event.UiCmdStop; goto stopTest; }
+                    if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+                    if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
                 }
                 while (e.Contains(Event.ValvesBusy));
 #endif
             }
 
 
-			///
-			/// Optionally display prompt to emerge temperature meters to appropriate baths for heat meters test
-			///
-			IOperation heatMetersPromptOp = null;
-			if (heatMetersTestParams != null && !string.IsNullOrEmpty(heatMetersTestParams.Prompt))
-			{
-				/// Make sure the CycleBeginForm is closed
-				if (UIFlowControl.Stop == WaitBeginFormClosed()) goto stopTest;
+            ///
+            /// Optionally display prompt to emerge temperature meters to appropriate baths for heat meters test
+            ///
+            IOperation heatMetersPromptOp = null;
+            if (heatMetersTestParams != null && !string.IsNullOrEmpty(heatMetersTestParams.Prompt))
+            {
+                /// Make sure the CycleBeginForm is closed
+                if (UIFlowControl.Stop == WaitBeginFormClosed()) goto stopTest;
 
-				heatMetersPromptOp = new Operations.MessageBoxOp(heatMetersTestParams.Prompt);
-			}
+                heatMetersPromptOp = new Operations.MessageBoxOp(heatMetersTestParams.Prompt);
+            }
 
 
             //------------------------------------------------
             Bridge.OnActivity(this, Strings.Starting_the_pump);
             //------------------------------------------------
 
-			Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
-			int flowSetTime0 = StateMachine.Time;
+            Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
+            int flowSetTime0 = StateMachine.Time;
 
 
             if (inPath.Pump is GenericDevices.IPumpFM)
@@ -227,12 +231,13 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
             ///
             State.Create(string.Format("{0}({1}) : Starting pump {2}", test.Method, test.Name, (inPath.Pump != null) ? inPath.Pump.Name : "?"))
                  .AddOperation(checkUiOp)
-//                 .AddOperation(new Operations.SetAllRegulValvesOp(inPath.RegulValves, inPath.RegulValvesPct, 60))
+                 //                 .AddOperation(new Operations.SetAllRegulValvesOp(inPath.RegulValves, inPath.RegulValvesPct, 60))
                  .AddOperations(readTempPressOps)
                  .AddOperation(heatMetersPromptOp)
                  .AddOperation(inPath.Pump != null ? cBrd.SetValvesOp(inPath.Pump, null) : null)
                  .EnterState();
-            do {
+            do
+            {
                 e = StateMachine.WaitRunDevsRunOps();
                 Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
 
@@ -249,8 +254,9 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
                      .AddOperation(new Operations.TimerOp(test.TimePump2StartV))
                      .AddOperations(readTempPressOps)
                      .AddOperation(heatMetersPromptOp)
-	 				 .EnterState();
-                do {
+                      .EnterState();
+                do
+                {
                     e = StateMachine.WaitRunDevsRunOps();
                     Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
 
@@ -267,11 +273,12 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
                      .AddOperation(cBrd.SetValvesOp(benchPath.StopBFValve, null))
                      .AddOperations(readTempPressOps)
                      .AddOperation(heatMetersPromptOp)
-					 .EnterState();
-                do {
+                     .EnterState();
+                do
+                {
                     e = StateMachine.WaitRunDevsRunOps();
-                    if (TestAndLogUiCmdStop(test, e))   { retVal = Event.UiCmdStop; goto stopTest; }
-                    if (e.Contains(Event.Error))        { retVal = Event.Error; goto stopTest; }
+                    if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
+                    if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
                 }
                 while (!e.Contains(Event.ValvesSet));
             }
@@ -284,8 +291,9 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
                      .AddOperation(new Operations.TimerOp(test.TimeBeforeFlow))
                      .AddOperations(readTempPressOps)
                      .AddOperation(heatMetersPromptOp)
-					 .EnterState();
-                do {
+                     .EnterState();
+                do
+                {
                     e = StateMachine.WaitRunDevsRunOps();
                     Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
 
@@ -302,13 +310,14 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
                  .AddOperation(cBrd.SetFlowOp(test.QfromM3ph(), test.QtoM3ph(), RefFlow, FlowSettingTimeoutSec))
                  .AddOperations(readTempPressOps)
                  .AddOperation(heatMetersPromptOp)
-				 .EnterState();
-            do {
+                 .EnterState();
+            do
+            {
                 e = StateMachine.WaitRunDevsRunOps();
                 Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
 
-                if (e.Contains(Event.OpArgumentError))  { retVal = Event.OpArgumentError; goto stopTest; }
-                if (TestAndLogUiCmdStop(test, e))       { retVal = Event.UiCmdStop; goto stopTest; }
+                if (e.Contains(Event.OpArgumentError)) { retVal = Event.OpArgumentError; goto stopTest; }
+                if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
                 if (e.Contains(Event.RegulValveTimeOut))
                 {
                     Bridge.OnError(this, Strings.Flow_adjustment_failed);
@@ -334,12 +343,13 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
                 double Tw_last = 0;
                 double Tc_last = 0;
 
-				State.Create(string.Format("{0}({1}) : Check temperature stabilized.", test.Method, test.Name))
+                State.Create(string.Format("{0}({1}) : Check temperature stabilized.", test.Method, test.Name))
                      .AddOperation(checkUiOp)
                      .AddOperations(readTempPressOps)
                      .AddOperation(heatMetersPromptOp)
-					 .EnterState();
-                do {
+                     .EnterState();
+                do
+                {
                     e = StateMachine.WaitRunDevsRunOps();
                     if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
                     if (e.Contains(Event.Next)) goto temperature_set;
@@ -368,63 +378,64 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
                 }
                 while (true);
             }
-			else if (!string.IsNullOrEmpty(test.TempControl) && benchPath.TempMtrUp != null && benchPath.TempMtrDown != null)
-			{
-				//---------------------------------------------------
-				Bridge.OnActivity(this, Strings.Setting_temperature);
-				//---------------------------------------------------
-
-				State.Create(string.Format("{0}({1}) : Wait until the water temperature is within limits", test.Method, test.Name))
-					 .AddOperation(checkUiOp)
+            else if (!string.IsNullOrEmpty(test.TempControl) && benchPath.TempMtrUp != null && benchPath.TempMtrDown != null)
+            {
+                //---------------------------------------------------
+                Bridge.OnActivity(this, Strings.Setting_temperature);
+                //---------------------------------------------------
+
+                State.Create(string.Format("{0}({1}) : Wait until the water temperature is within limits", test.Method, test.Name))
+                     .AddOperation(checkUiOp)
                      .AddOperations(readTempPressOps)
                      .EnterState();
-				do {
-					e = StateMachine.WaitRunDevsRunOps();
-					if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
-					if (e.Contains(Event.Next)) goto temperature_set;
+                do
+                {
+                    e = StateMachine.WaitRunDevsRunOps();
+                    if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
+                    if (e.Contains(Event.Next)) goto temperature_set;
 
                     if ((test.TempLimLo <= TempUp.Val) && (TempUp.Val <= test.TempLimHi) &&
                         (test.TempLimLo <= TempDown.Val) && (TempDown.Val <= test.TempLimHi))
                     {
-						goto temperature_set;
-					}
-				}
-				while (true);
-			}
+                        goto temperature_set;
+                    }
+                }
+                while (true);
+            }
 
         temperature_set:
 
             ///
-			/// Prepare cameras, ROI-s and measurementOperations
-			///
+            /// Prepare cameras, ROI-s and measurementOperations
+            ///
 
-			/// Find successfully detected ROI-s
-			IList<GenericDevices.IRegReaderLiveCamera> rois = new List<GenericDevices.IRegReaderLiveCamera>();
-			foreach (var rr in sensPath.RegisterReaders)
-			{
+            /// Find successfully detected ROI-s
+            IList<GenericDevices.IRegReaderLiveCamera> rois = new List<GenericDevices.IRegReaderLiveCamera>();
+            foreach (var rr in sensPath.RegisterReaders)
+            {
                 GenericDevices.IRegReaderLiveCamera cameraRoI = rr as GenericDevices.IRegReaderLiveCamera;
                 if ((cameraRoI != null) && cameraRoI.Detected)
                 {
                     rois.Add(cameraRoI);
                 }
-			}
+            }
 
-			/// Find cameras
-			IList<GenericDevices.ICamera> cameras = new List<GenericDevices.ICamera>();
+            /// Find cameras
+            IList<GenericDevices.ICamera> cameras = new List<GenericDevices.ICamera>();
             foreach (var roi in rois)
             {
-				if (roi.Camera != null && !cameras.Contains(roi.Camera))
-				{
-					cameras.Add(roi.Camera);
-					roi.Camera.ClearRoiParams();
-				}
+                if (roi.Camera != null && !cameras.Contains(roi.Camera))
+                {
+                    cameras.Add(roi.Camera);
+                    roi.Camera.ClearRoiParams();
+                }
             }
 
-			/// Register ROI-parameters to cameras
-			foreach (var roi in rois) roi.RegisterRoiToCamera();
+            /// Register ROI-parameters to cameras
+            foreach (var roi in rois) roi.RegisterRoiToCamera();
 
-			/// Prepare measurementOperations
-			IList<IOperation> cameraMeasurementOps = new List<IOperation>();
+            /// Prepare measurementOperations
+            IList<IOperation> cameraMeasurementOps = new List<IOperation>();
             foreach (var camera in cameras)
             {
                 cameraMeasurementOps.Add(camera.MeasurementOp());
@@ -446,60 +457,62 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
             }
 
 
-			if (drainTheTank)
-			{
-				//------------------------------------------------
-				Bridge.OnActivity(this, Strings.Closing_the_tank);
-				//------------------------------------------------
+            if (drainTheTank)
+            {
+                //------------------------------------------------
+                Bridge.OnActivity(this, Strings.Closing_the_tank);
+                //------------------------------------------------
 
-				///
-				/// Make sure tank draining completed
-				///
+                ///
+                /// Make sure tank draining completed
+                ///
                 switch (DrainTheTank(scale, readTempPressOps))
-				{
-					case Event.Error: { retVal = Event.Error; goto stopTest; }
-					case Event.UiCmdStop: { retVal = Event.UiCmdStop; goto stopTest; }
-				}
+                {
+                    case Event.Error: { retVal = Event.Error; goto stopTest; }
+                    case Event.UiCmdStop: { retVal = Event.UiCmdStop; goto stopTest; }
+                }
 
-				drainTheTank = false;
-			}
-			else
-			{
-				/// Close the drain valve anyway
-				State.Create(string.Format("{0}({1}) : Close the drain valve", test.Method, test.Name))
-					 .AddOperation(checkUiOp)
+                drainTheTank = false;
+            }
+            else
+            {
+                /// Close the drain valve anyway
+                State.Create(string.Format("{0}({1}) : Close the drain valve", test.Method, test.Name))
+                     .AddOperation(checkUiOp)
                      .AddOperations(readTempPressOps)
                      .AddOperation(cBrd.SetValvesOp(null, scale.DrainValve))
                      .EnterState();
-				do {
-					e = StateMachine.WaitRunDevsRunOps();
-					if (e.Contains(Event.Error))	  { retVal = Event.Error; goto stopTest;	 }
-					if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
-				}
-				while (e.Contains(Event.ValvesBusy));
-			}
+                do
+                {
+                    e = StateMachine.WaitRunDevsRunOps();
+                    if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+                    if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
+                }
+                while (e.Contains(Event.ValvesBusy));
+            }
 
 
-			//----------------------------------------------------
-			Bridge.OnActivity(this, Strings.Measuring_the_weight);
-			//----------------------------------------------------
+            //----------------------------------------------------
+            Bridge.OnActivity(this, Strings.Measuring_the_weight);
+            //----------------------------------------------------
 
             LogProcessDataTestInfo(processDataLogger, test.Procedure.Name, test.Name);
 
-			if (heatMetersPath == null) LogProcessDataHeader(processDataLogger, "Start mass");
-			else LogProcessDataHeaderHeatMeters(processDataLogger, "Start mass");
-    
-			State.Create(string.Format("{0}({1}) : Measuring the start mass", test.Method, test.Name))
-				 .AddOperation(checkUiOp)
+            if (heatMetersPath == null) LogProcessDataHeader(processDataLogger, "Start mass");
+            else LogProcessDataHeaderHeatMeters(processDataLogger, "Start mass");
+
+            State.Create(string.Format("{0}({1}) : Measuring the start mass", test.Method, test.Name))
+                 .AddOperation(checkUiOp)
                  .AddOperations(readTempPressOps)
                  .AddOperations(cameraMeasurementOps)
                  .AddOperation(scale.ReadStableMassOp(ref StartMass, test.TimeFlow2Mass, test.MassMethod, test.MassRepeats, test.MassSpread))
                  .AddOperation(processDataLoggingOp)
                  .EnterState();
-			do {
-				e = StateMachine.WaitRunDevsRunOps();
-				if (e.Contains(Event.Error))	   { retVal = Event.Error;	   goto stopTest; }
-				if (TestAndLogUiCmdStop(test,e))   { retVal = Event.UiCmdStop; goto stopTest; }
+            do
+            {
+                e = StateMachine.WaitRunDevsRunOps();
+                if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+                if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
                 if (e.Contains(Event.ScaleTimeout))
                 {
                     Bridge.OnError(this, Strings.Mass_measurement_timeout);
@@ -513,9 +526,9 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
             log.WarnFormat("Start mass = {0}kg", StartMass);
 
 
-			if (heatMetersPath == null)
+            if (heatMetersPath == null)
                 LogProcessDataHeader(processDataLogger, "Measurement");
-			else
+            else
                 LogProcessDataHeaderHeatMeters(processDataLogger, "Measurement");
 
             //------------------------------------------------
@@ -531,18 +544,19 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
 
             /// Measurement loop
             State.Create(string.Format("{0}({1}) : FlyingStartStopTestWithDivOp is running", test.Method, test.Name))
-				 .AddOperation(checkUiOp)
+                 .AddOperation(checkUiOp)
                  .AddOperations(readTempPressOps)
                  .AddOperations(readDatastreamOps)
                  .AddOperations(cameraMeasurementOps)
                  .AddOperation(cBrd.FlyingStartStopTestOp(test, test.QfromM3ph(), test.QtoM3ph(), totalPulses, true, isDelayedStart, false, 0, true, DiverterStart, DiverterEnd))
                  .AddOperation(processDataLoggingOp)
                  .EnterState();
-            do {
+            do
+            {
                 e = StateMachine.WaitRunDevsRunOps();
                 if (e.Contains(Event.OpArgumentError)) { retVal = Event.OpArgumentError; goto stopTest; }
-                if (e.Contains(Event.Error))           { retVal = Event.Error;           goto stopTest; }
-                if (TestAndLogUiCmdStop(test, e))      { retVal = Event.UiCmdStop;       goto stopTest; }
+                if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+                if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
 
                 /// Show remaining time
                 if ((remainingTime = Math.Max(estimtdEndTime - StateMachine.Time, 0)) > 60)
@@ -602,32 +616,34 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
                      .AddOperations(readTempPressOps)
                      .AddOperation(cBrd.SetValvesOp(StateMachine.DefaultValvesOpen, StateMachine.DefaultValvesClose))
                      .EnterState();
-                do {
+                do
+                {
                     e = StateMachine.WaitRunDevsRunOps();
-                    if (e.Contains(Event.Error))    { retVal = Event.Error;     goto stopTest; }
-                    if (TestAndLogUiCmdStop(e))     { retVal = Event.UiCmdStop; goto stopTest; }
+                    if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+                    if (TestAndLogUiCmdStop(e)) { retVal = Event.UiCmdStop; goto stopTest; }
                 }
                 while (!e.Contains(Event.ValvesSet));
             }
 
-			//------------------------------------------------
-			Bridge.OnActivity(this, Strings.Measuring_the_weight);
-			//------------------------------------------------
+            //------------------------------------------------
+            Bridge.OnActivity(this, Strings.Measuring_the_weight);
+            //------------------------------------------------
 
-			if (heatMetersPath == null) LogProcessDataHeader(processDataLogger, "End mass");
-			else LogProcessDataHeaderHeatMeters(processDataLogger, "End mass");
+            if (heatMetersPath == null) LogProcessDataHeader(processDataLogger, "End mass");
+            else LogProcessDataHeaderHeatMeters(processDataLogger, "End mass");
 
             State.Create(string.Format("{0}({1}) : Measuring the end mass", test.Method, test.Name))
-				 .AddOperation(checkUiOp)
+                 .AddOperation(checkUiOp)
                  .AddOperations(readTempPressOps)
                  .AddOperation(scale.ReadStableMassOp(ref EndMass, test.TimeStop2Mass, test.MassMethod, test.MassRepeats, test.MassSpread))
                  .AddOperation(new Operations.TimerOp(StableMassMsrmntTimeoutSec))
                  .AddOperation(processDataLoggingOp)
                  .EnterState();
-			do {
-				e = StateMachine.WaitRunDevsRunOps();
-				if (e.Contains(Event.Error))	 { retVal = Event.Error;	 goto stopTest; }
-				if (TestAndLogUiCmdStop(test,e)) { retVal = Event.UiCmdStop; goto stopTest; }
+            do
+            {
+                e = StateMachine.WaitRunDevsRunOps();
+                if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+                if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
                 if (e.Contains(Event.ScaleTimeout))
                 {
                     Bridge.OnError(this, Strings.Mass_measurement_timeout);
@@ -639,7 +655,7 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
             ///
             tMass2 = StateMachine.Time;
             log.WarnFormat("End mass = {0}kg", EndMass);
-			TestEndTime = DateTime.Now;
+            TestEndTime = DateTime.Now;
 
             if (test.DoDrainingAfter)
             {
@@ -648,47 +664,48 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
                      .AddOperation(cBrd.SetValvesOp(scale.DrainValve, null))
                      .AddOperations(readTempPressOps)
                      .EnterState();
-                do {
+                do
+                {
                     e = StateMachine.WaitRunDevsRunOps();
                     if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
                 }
                 while (e.Contains(Event.ValvesBusy));
             }
 
-			//------------------------------------------------
-			Bridge.OnActivity(this, Strings.Test_completed);
-			//------------------------------------------------
+            //------------------------------------------------
+            Bridge.OnActivity(this, Strings.Test_completed);
+            //------------------------------------------------
 
-			/// Make sure the CycleBeginForm is closed so that water meter data (s/n) can be copied into results
-			if (heatMetersPromptOp == null)
-			{
-				if (UIFlowControl.Stop == WaitBeginFormClosed()) goto stopTest;
-			}
+            /// Make sure the CycleBeginForm is closed so that water meter data (s/n) can be copied into results
+            if (heatMetersPromptOp == null)
+            {
+                if (UIFlowControl.Stop == WaitBeginFormClosed()) goto stopTest;
+            }
 
-			///
-			/// Populate TestResult data entity with data
-			/// 
-			Results.Entities.TestRslt tstRslt = BatchRslts.GetTestRslt(testName, test.Part);
+            ///
+            /// Populate TestResult data entity with data
+            /// 
+            Results.Entities.TestRslt tstRslt = BatchRslts.GetTestRslt(testName, test.Part);
 
             bool stopCycle = false;
             if (tstRslt != null)
             {
                 Results.Utils.GetCounterStates(tstRslt, Program.LocalSettings.Counters);
 
-				/// Raw data
+                /// Raw data
                 UpdateTempPressDensAmb(tstRslt);
-                tstRslt.MethodClass    = TbfComponents.FindComponent(test.Method).ClassName;
-                tstRslt.StartTime      = TestStartTime;
-				tstRslt.EndTime        = TestEndTime;
-				tstRslt.FlowSetTime    = flowSetTime;
-                tstRslt.TestTime       = cBrd.TestTime;					        /// [s] measurement time
-                tstRslt.PulsesMaster   = Convert.ToDouble(cBrd.RefPulses);	    /// Pulses of the master flow meter (test total)
-				tstRslt.MassStartRaw   = StartMass.Val;
-				tstRslt.MassEndRaw     = EndMass.Val;
+                tstRslt.MethodClass = TbfComponents.FindComponent(test.Method).ClassName;
+                tstRslt.StartTime = TestStartTime;
+                tstRslt.EndTime = TestEndTime;
+                tstRslt.FlowSetTime = flowSetTime;
+                tstRslt.TestTime = cBrd.TestTime;					        /// [s] measurement time
+                tstRslt.PulsesMaster = Convert.ToDouble(cBrd.RefPulses);	    /// Pulses of the master flow meter (test total)
+				tstRslt.MassStartRaw = StartMass.Val;
+                tstRslt.MassEndRaw = EndMass.Val;
                 tstRslt.TimeBtwnMassMsrmnts = tMass2 - tMass1;
                 tstRslt.ConstMasterRaw = outPath.FlowMeter.LtrPerPulse;
-                tstRslt.VolumeMaster   = tstRslt.ConstMasterRaw * tstRslt.PulsesMaster; /// [l] volume from the master flow meter
-                double flowMID         = 3.6 * tstRslt.VolumeMaster / tstRslt.TestTime; /// [m3/h] flow before correction from the master flow meter
+                tstRslt.VolumeMaster = tstRslt.ConstMasterRaw * tstRslt.PulsesMaster; /// [l] volume from the master flow meter
+                double flowMID = 3.6 * tstRslt.VolumeMaster / tstRslt.TestTime; /// [m3/h] flow before correction from the master flow meter
 
                 /// Corrected data
                 tstRslt.MassStart = MeasurementCorrection.CorrectedValue(tstRslt.MassStartRaw, scale.Corrections);
@@ -698,23 +715,37 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
                 tstRslt.ConstMasterCorr = outPath.FlowMeter.LtrPerPulseCorrected(flowMID, tstRslt.TempDownMean);
 
                 /// Main result calculation
-                tstRslt.VolumeCTV    = 1000 * tstRslt.Batch.Buoyancy * mass / tstRslt.DensityLine;
+                tstRslt.VolumeCTV = 1000 * tstRslt.Batch.Buoyancy * mass / tstRslt.DensityLine;
                 if ((outPath.Diverter != null) && (tstRslt.TestTime > float.Epsilon))
                 {
                     tstRslt.TestTimeCorrection = outPath.Diverter.TestTimeCorrection(flowMID);
                     tstRslt.VolumeCTV *= tstRslt.TestTime + tstRslt.TestTimeCorrection;
                     tstRslt.VolumeCTV /= tstRslt.TestTime;
                 }
-                tstRslt.Flow        = 3.6 * tstRslt.VolumeCTV / tstRslt.TestTime;       /// Flow from VolumeCTV and time
+                tstRslt.Flow = 3.6 * tstRslt.VolumeCTV / tstRslt.TestTime;       /// Flow from VolumeCTV and time
                 tstRslt.ErrorMaster = Formulas.ErrorFromVolumes(tstRslt.VolumeMaster, tstRslt.VolumeCTV);
                 tstRslt.ConstMaster = (tstRslt.PulsesMaster != 0) ? (tstRslt.VolumeCTV / tstRslt.PulsesMaster) : tstRslt.ConstMasterCorr;
-                                                                                        /// Master pulses per liter from the measured mass
+                /// Master pulses per liter from the measured mass
+
+                /// Main result calculation for mass
+                tstRslt.MassCTV = tstRslt.Batch.Buoyancy * mass;
+                if ((outPath.Diverter != null) && (tstRslt.TestTime > float.Epsilon))
+                {
+                    tstRslt.TestTimeCorrection = outPath.Diverter.TestTimeCorrection(flowMID);
+                    tstRslt.MassCTV *= tstRslt.TestTime + tstRslt.TestTimeCorrection;
+                    tstRslt.MassCTV /= tstRslt.TestTime;
+                }
+                tstRslt.MassFlow = 3.6 * tstRslt.MassCTV / tstRslt.TestTime;       /// Flow from MassCTV and time
+                tstRslt.MassErrorMaster = Formulas.ErrorFromVolumes(tstRslt.VolumeMaster, tstRslt.MassCTV);
+                tstRslt.MassConstMaster = (tstRslt.PulsesMaster != 0) ? (tstRslt.MassCTV / tstRslt.PulsesMaster) : tstRslt.ConstMasterCorr;
+
+
                 /// Flow statistics correction
-                tstRslt.FlowMean  = Convert.ToSingle(tstRslt.ConstMaster * RefFlowStat.Average / tstRslt.ConstMasterRaw);
+                tstRslt.FlowMean = Convert.ToSingle(tstRslt.ConstMaster * RefFlowStat.Average / tstRslt.ConstMasterRaw);
                 tstRslt.FlowStart = Convert.ToSingle(tstRslt.ConstMaster * RefFlowStat.First / tstRslt.ConstMasterRaw);
-                tstRslt.FlowEnd   = Convert.ToSingle(tstRslt.ConstMaster * RefFlowStat.Last / tstRslt.ConstMasterRaw);
-                tstRslt.FlowMin   = Convert.ToSingle(tstRslt.ConstMaster * RefFlowStat.Min / tstRslt.ConstMasterRaw);
-                tstRslt.FlowMax   = Convert.ToSingle(tstRslt.ConstMaster * RefFlowStat.Max / tstRslt.ConstMasterRaw);
+                tstRslt.FlowEnd = Convert.ToSingle(tstRslt.ConstMaster * RefFlowStat.Last / tstRslt.ConstMasterRaw);
+                tstRslt.FlowMin = Convert.ToSingle(tstRslt.ConstMaster * RefFlowStat.Min / tstRslt.ConstMasterRaw);
+                tstRslt.FlowMax = Convert.ToSingle(tstRslt.ConstMaster * RefFlowStat.Max / tstRslt.ConstMasterRaw);
 
                 tstRslt.DiverterStart = outPath.Diverter.SwitchTimeStart.Val;
                 tstRslt.DivStart10 = 0;
@@ -734,114 +765,114 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
                     : 0;
                 tstRslt.InfoFlags = infoFlags;
 
-				if (compoundTestParams != null)
-				{
-					///
-					/// Compound meters
-					///
-					for (int i = 0; i < BatchRslts.WMPositionsCount; i++)
-					{
-						if (!test.IsPartCompatible(Utils.PartNr(i + 1, BatchRslts.Batch.Compound))) continue;
+                if (compoundTestParams != null)
+                {
+                    ///
+                    /// Compound meters
+                    ///
+                    for (int i = 0; i < BatchRslts.WMPositionsCount; i++)
+                    {
+                        if (!test.IsPartCompatible(Utils.PartNr(i + 1, BatchRslts.Batch.Compound))) continue;
 
-						var mainMeterRslt = BatchRslts.GetMeterTestRslt(testName, i, CompoundMeterId.CompoundMain);
-						var auxMeterRslt = BatchRslts.GetMeterTestRslt(testName, i, CompoundMeterId.CompoundAux);
+                        var mainMeterRslt = BatchRslts.GetMeterTestRslt(testName, i, CompoundMeterId.CompoundMain);
+                        var auxMeterRslt = BatchRslts.GetMeterTestRslt(testName, i, CompoundMeterId.CompoundAux);
 
-						for (int isAux = 0; isAux <= 1; isAux++)		/// 0=main, 1=aux
+                        for (int isAux = 0; isAux <= 1; isAux++)		/// 0=main, 1=aux
 						{
-							IRegReader regReader = sensPath.RegisterReaders[2 * i + isAux];
-							var oneMTR = (isAux == 0) ? mainMeterRslt : auxMeterRslt;
+                            IRegReader regReader = sensPath.RegisterReaders[2 * i + isAux];
+                            var oneMTR = (isAux == 0) ? mainMeterRslt : auxMeterRslt;
 
-							if (oneMTR != null && regReader != null)
-							{
+                            if (oneMTR != null && regReader != null)
+                            {
                                 oneMTR.RegReaderType = (int)regReader.RegisterReaderType;
                                 if (regReader is PoseidonReader poseidon) //is Poseidon reader family
                                 {
-	                                oneMTR.PulsesPerLiter = 0;
-
-	                                /// Optionally supress pulses from the large water meter
-	                                oneMTR.PulsesMeter = 0;
-	                                oneMTR.PulsesMaster = 0;
-	                                oneMTR.TestTime = cBrd.TestTime;
-	                                oneMTR.VolumeStart = 0;
-	                                oneMTR.VolumeEnd = 0;
-	                                oneMTR.VolumeRef = tstRslt.VolumeCTV;
-
-	                                if (oneMTR.PulsesMaster != 0)
-	                                {
-		                                oneMTR.PulsesMeter *= (tstRslt.PulsesMaster / oneMTR.PulsesMaster);
-		                                oneMTR.PulsesMaster = tstRslt.PulsesMaster;
-	                                }
-
-	                                oneMTR.VolumeMeter = poseidon.WMVolume;
-	                                
-	                                oneMTR.Error =
-		                                Formulas.ErrorFromVolumes(oneMTR.VolumeMeter,
-			                                tstRslt.VolumeCTV); /// Main/Aux meter error is not usedfor evaluation
+                                    oneMTR.PulsesPerLiter = 0;
+
+                                    /// Optionally supress pulses from the large water meter
+                                    oneMTR.PulsesMeter = 0;
+                                    oneMTR.PulsesMaster = 0;
+                                    oneMTR.TestTime = cBrd.TestTime;
+                                    oneMTR.VolumeStart = 0;
+                                    oneMTR.VolumeEnd = 0;
+                                    oneMTR.VolumeRef = tstRslt.VolumeCTV;
+
+                                    if (oneMTR.PulsesMaster != 0)
+                                    {
+                                        oneMTR.PulsesMeter *= (tstRslt.PulsesMaster / oneMTR.PulsesMaster);
+                                        oneMTR.PulsesMaster = tstRslt.PulsesMaster;
+                                    }
+
+                                    oneMTR.VolumeMeter = poseidon.WMVolume;
+
+                                    oneMTR.Error =
+                                        Formulas.ErrorFromVolumes(oneMTR.VolumeMeter,
+                                            tstRslt.VolumeCTV); /// Main/Aux meter error is not usedfor evaluation
                                 }
                                 else
                                 {
-	                                oneMTR.PulsesPerLiter = regReader.PulsesPerLtr;
-
-	                                /// Optionally supress pulses from the large water meter
-	                                oneMTR.PulsesMeter = (isAux == 0 && compoundTestParams.SupressTrills)
-		                                ? 0
-		                                : Convert.ToDouble(regReader.WMPulses);
-	                                oneMTR.PulsesMaster = Convert.ToDouble(regReader.WMRefPulses);
-	                                oneMTR.TestTime = cBrd.TestTime;
-	                                oneMTR.VolumeStart = 0;
-	                                oneMTR.VolumeEnd = 0;
-	                                oneMTR.VolumeRef = tstRslt.VolumeCTV;
-
-	                                if (oneMTR.PulsesMaster != 0)
-	                                {
-		                                oneMTR.PulsesMeter *= (tstRslt.PulsesMaster / oneMTR.PulsesMaster);
-		                                oneMTR.PulsesMaster = tstRslt.PulsesMaster;
-	                                }
-
-	                                oneMTR.VolumeMeter = oneMTR.PulsesMeter * regReader.LtrsPerPulse; /// liter
-
-	                                oneMTR.Error =
-		                                Formulas.ErrorFromVolumes(oneMTR.VolumeMeter,
-			                                tstRslt.VolumeCTV); /// Main/Aux meter error is not usedfor evaluation
+                                    oneMTR.PulsesPerLiter = regReader.PulsesPerLtr;
+
+                                    /// Optionally supress pulses from the large water meter
+                                    oneMTR.PulsesMeter = (isAux == 0 && compoundTestParams.SupressTrills)
+                                        ? 0
+                                        : Convert.ToDouble(regReader.WMPulses);
+                                    oneMTR.PulsesMaster = Convert.ToDouble(regReader.WMRefPulses);
+                                    oneMTR.TestTime = cBrd.TestTime;
+                                    oneMTR.VolumeStart = 0;
+                                    oneMTR.VolumeEnd = 0;
+                                    oneMTR.VolumeRef = tstRslt.VolumeCTV;
+
+                                    if (oneMTR.PulsesMaster != 0)
+                                    {
+                                        oneMTR.PulsesMeter *= (tstRslt.PulsesMaster / oneMTR.PulsesMaster);
+                                        oneMTR.PulsesMaster = tstRslt.PulsesMaster;
+                                    }
+
+                                    oneMTR.VolumeMeter = oneMTR.PulsesMeter * regReader.LtrsPerPulse; /// liter
+
+                                    oneMTR.Error =
+                                        Formulas.ErrorFromVolumes(oneMTR.VolumeMeter,
+                                            tstRslt.VolumeCTV); /// Main/Aux meter error is not usedfor evaluation
                                 }
-							}
-						}
+                            }
+                        }
 
-						var compoundMTR = BatchRslts.GetMeterTestRslt(testName, i, CompoundMeterId.Compound);
+                        var compoundMTR = BatchRslts.GetMeterTestRslt(testName, i, CompoundMeterId.Compound);
 
-						if (compoundMTR != null && mainMeterRslt != null && auxMeterRslt != null)
-						{
-							compoundMTR.VolumeRef    = tstRslt.VolumeCTV;
-							compoundMTR.VolumeMeter  = mainMeterRslt.VolumeMeter + auxMeterRslt.VolumeMeter;
-							compoundMTR.PulsesMaster = tstRslt.PulsesMaster;
-							compoundMTR.TestTime     = tstRslt.TestTime;
-                            compoundMTR.Error        = Formulas.ErrorFromVolumes(compoundMTR.VolumeMeter, compoundMTR.VolumeRef);
-							compoundMTR.Passed       = (compoundMTR.Error >= test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime) + test.Uncertainty)
-													&& (compoundMTR.Error <= test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime) - test.Uncertainty)
+                        if (compoundMTR != null && mainMeterRslt != null && auxMeterRslt != null)
+                        {
+                            compoundMTR.VolumeRef = tstRslt.VolumeCTV;
+                            compoundMTR.VolumeMeter = mainMeterRslt.VolumeMeter + auxMeterRslt.VolumeMeter;
+                            compoundMTR.PulsesMaster = tstRslt.PulsesMaster;
+                            compoundMTR.TestTime = tstRslt.TestTime;
+                            compoundMTR.Error = Formulas.ErrorFromVolumes(compoundMTR.VolumeMeter, compoundMTR.VolumeRef);
+                            compoundMTR.Passed = (compoundMTR.Error >= test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime) + test.Uncertainty)
+                                                    && (compoundMTR.Error <= test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime) - test.Uncertainty)
                                                     && (tstRslt.ErrorFlags == 0);
-                            mainMeterRslt.Passed     = auxMeterRslt.Passed = compoundMTR.Passed;
-							mainMeterRslt.TestDone   = auxMeterRslt.TestDone = compoundMTR.TestDone = true;
+                            mainMeterRslt.Passed = auxMeterRslt.Passed = compoundMTR.Passed;
+                            mainMeterRslt.TestDone = auxMeterRslt.TestDone = compoundMTR.TestDone = true;
                             tstRslt.TestDone = true;
-						}
-					}
-				}
-				else if (heatMetersTestParams != null)
-				{
+                        }
+                    }
+                }
+                else if (heatMetersTestParams != null)
+                {
                     ///
                     /// Heat meters
                     ///
                     tstRslt.RefEnergy = Energy.Sum * tstRslt.VolumeCTV / VolumeForEnergy.Sum;   /// [J] = [J] * [l] / [l]
 
-					tstRslt.Custom1  = (float)TempRefHiStat.Average;
-					tstRslt.Custom2  = (float)TempRefHiStat.First;
-					tstRslt.Custom3  = (float)TempRefHiStat.Last;
-					tstRslt.Custom4  = (float)TempRefHiStat.Min;
-					tstRslt.Custom5  = (float)TempRefHiStat.Max;
-					tstRslt.Custom6  = (float)TempRefLoStat.Average;
-					tstRslt.Custom7  = (float)TempRefLoStat.First;
-					tstRslt.Custom8  = (float)TempRefLoStat.Last;
-					tstRslt.Custom9  = (float)TempRefLoStat.Min;
-					tstRslt.Custom10 = (float)TempRefLoStat.Max;																								
+                    tstRslt.Custom1 = (float)TempRefHiStat.Average;
+                    tstRslt.Custom2 = (float)TempRefHiStat.First;
+                    tstRslt.Custom3 = (float)TempRefHiStat.Last;
+                    tstRslt.Custom4 = (float)TempRefHiStat.Min;
+                    tstRslt.Custom5 = (float)TempRefHiStat.Max;
+                    tstRslt.Custom6 = (float)TempRefLoStat.Average;
+                    tstRslt.Custom7 = (float)TempRefLoStat.First;
+                    tstRslt.Custom8 = (float)TempRefLoStat.Last;
+                    tstRslt.Custom9 = (float)TempRefLoStat.Min;
+                    tstRslt.Custom10 = (float)TempRefLoStat.Max;
 
                     for (int i = 0; i < BatchRslts.WMPositionsCount; i++)
                     {
@@ -868,10 +899,10 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
                             volumeRslt.TestTime = cBrd.TestTimeWM(i + 1);                                   /// [s]
 
                             volumeRslt.Error = Formulas.ErrorFromVolumes(volumeRslt.VolumeMeter, volumeRslt.VolumeRef);
-							volumeRslt.Passed = !heatMetersTestParams.EvaluateVolume ||
-												((volumeRslt.Error >= test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime) + test.Uncertainty) &&
-												 (volumeRslt.Error <= test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime) - test.Uncertainty) &&
-        										 (tstRslt.ErrorFlags == 0));
+                            volumeRslt.Passed = !heatMetersTestParams.EvaluateVolume ||
+                                                ((volumeRslt.Error >= test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime) + test.Uncertainty) &&
+                                                 (volumeRslt.Error <= test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime) - test.Uncertainty) &&
+                                                 (tstRslt.ErrorFlags == 0));
                             volumeRslt.TestDone = true;
                             tstRslt.TestDone = true;
                         }
@@ -883,103 +914,131 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
                             energyRslt.PulsesMaster = Convert.ToDouble(energyRegReader.WMRefPulses);
                             energyRslt.VolumeStart = 0;
                             energyRslt.VolumeEnd = 0;
-							energyRslt.VolumeRef = tstRslt.RefEnergy * (energyRslt.PulsesMaster / tstRslt.PulsesMaster);	                            /// [J]
+                            energyRslt.VolumeRef = tstRslt.RefEnergy * (energyRslt.PulsesMaster / tstRslt.PulsesMaster);	                            /// [J]
 							energyRslt.VolumeMeter = energyRslt.PulsesMeter * Common.Units.ConvertFrom(Common.Unit.kWh, energyRegReader.LtrsPerPulse);	/// [J]
                             energyRslt.TestTime = cBrd.TestTimeWM(i + 1);                                   /// [s]
 
                             energyRslt.Error = Formulas.ErrorFromVolumes(energyRslt.VolumeMeter, energyRslt.VolumeRef);
-							energyRslt.Passed = (energyRslt.Error >= heatMetersTestParams.ErrorLimitLo)
-											 && (energyRslt.Error <= heatMetersTestParams.ErrorLimitHi)
+                            energyRslt.Passed = (energyRslt.Error >= heatMetersTestParams.ErrorLimitLo)
+                                             && (energyRslt.Error <= heatMetersTestParams.ErrorLimitHi)
                                              && (tstRslt.ErrorFlags == 0);
                             energyRslt.TestDone = true;
                             tstRslt.TestDone = true;
                         }
                     }
                 }
-				else
-				{
-					///
-					/// Single meters
-					///
-					for (int i = 0; i < BatchRslts.WMPositionsCount; i++)
-					{
-						if (!test.IsPartCompatible(Utils.PartNr(i + 1, BatchRslts.Batch.Compound))) continue;
-
-						/// MetersKind.Single meters
-						Results.Entities.MeterTestRslt meterRslt = BatchRslts.GetMeterTestRslt(testName, i, Common.CompoundMeterId.Single);
-						GenericDevices.IRegReader regReader = sensPath.RegisterReaders[i];
+                else
+                {
+                    ///
+                    /// Single meters
+                    ///
+                    for (int i = 0; i < BatchRslts.WMPositionsCount; i++)
+                    {
+                        if (!test.IsPartCompatible(Utils.PartNr(i + 1, BatchRslts.Batch.Compound))) continue;
+
+                        /// MetersKind.Single meters
+                        Results.Entities.MeterTestRslt meterRslt = BatchRslts.GetMeterTestRslt(testName, i, Common.CompoundMeterId.Single);
+                        GenericDevices.IRegReader regReader = sensPath.RegisterReaders[i];
                         GenericDevices.IRegReaderDatastream dstrReader = regReader as GenericDevices.IRegReaderDatastream;
                         TestMethods.iPerlCommunication.iPerlHead.IperlHead iPerl = regReader as TestMethods.iPerlCommunication.iPerlHead.IperlHead;
                         GenericDevices.IRegReaderLiveCamera cameraRoi = regReader as GenericDevices.IRegReaderLiveCamera;
 
-						if (meterRslt != null && regReader != null)
-						{
+                        if (meterRslt != null && regReader != null)
+                        {
                             meterRslt.RegReaderType = (int)regReader.RegisterReaderType;
-                            meterRslt.PulsesPerLiter = regReader.PulsesPerLtr;
-							meterRslt.PulsesMeter = Convert.ToDouble(regReader.WMPulses);
+                            ComponentProcedure procParamsEntity = test.Procedure.GetProcedureParamsEntity(regReader.Name);
+
+                            try
+                            {
+                                if (regReader.RegisterReaderType == RegisterReaderType.Pulses)
+                                {
+                                    XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(RRProcParams) })[0];
+                                    RRProcParams tmp = Serializer.Deserialize(new StringReader(procParamsEntity.Parameters.ToString())) as RRProcParams;
+                                    regReader.PulsesPerLtr = tmp.PulsesPerLtr;
+                                    regReader.QuantityUnits = tmp.Units;
+                                }
+                                else
+                                {
+                                    //MessageBox.Show("Cannot create or initialize a printer", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
+                                }
+                            }
+                            catch (Exception ex)
+                            {
+                                /*log.DebugFormat(
+                                    "Error during Procedure parameters deserialization. CmpntName='{0}', Procedure='{1}', Parameters='{2}', Exception: {3}",
+                                    dbEntity?.CmpntName,
+                                    dbEntity?.Procedure,
+                                    dbEntity?.Parameters,
+                                    ex
+                                );*/
+                            }
+
+                            meterRslt.PulsesPerLiter = regReader.PulsesPerLtr;//...MF 11.12.2025 toto chybalo, v .csv bol stlpec naplneny nulami
+                            meterRslt.QuantityUnits = regReader.QuantityUnits;
+                            meterRslt.PulsesMeter = Convert.ToDouble(regReader.WMPulses);
 
                             if (dstrReader != null)
-							{
-
-								if (dstrReader is SmartReader poseidon) //is Poseidon reader family
-								{
-									log.Info("Poseidon reader detected - Results");
-									meterRslt.TimestampStart = poseidon.TimestampSecStart;
-									meterRslt.TimestampEnd = !poseidon.NoSamples
-										? poseidon.TimestampSecEnd
-										: (poseidon.TimestampSecStart + tstRslt.TestTime);
-									meterRslt.TestTime = meterRslt.TimestampEnd - meterRslt.TimestampStart;
-									meterRslt.VolumeStart = poseidon.VolumeLtrStart; /// liter
+                            {
+
+                                if (dstrReader is SmartReader poseidon) //is Poseidon reader family
+                                {
+                                    log.Info("Poseidon reader detected - Results");
+                                    meterRslt.TimestampStart = poseidon.TimestampSecStart;
+                                    meterRslt.TimestampEnd = !poseidon.NoSamples
+                                        ? poseidon.TimestampSecEnd
+                                        : (poseidon.TimestampSecStart + tstRslt.TestTime);
+                                    meterRslt.TestTime = meterRslt.TimestampEnd - meterRslt.TimestampStart;
+                                    meterRslt.VolumeStart = poseidon.VolumeLtrStart; /// liter
 									meterRslt.VolumeEnd = poseidon.VolumeLtrStart + poseidon.WMVolume; //dstrReader.VolumeLtrEnd; /// liter
-									meterRslt.VolumeMeter = poseidon.WMVolume;
-
-									if (!(meterRslt.TestTime == 0 || tstRslt.TestTime == 0))
-									{
-										meterRslt.VolumeRef = tstRslt.VolumeCTV * meterRslt.TestTime / tstRslt.TestTime;
-										meterRslt.PulsesMaster =
-											tstRslt.PulsesMaster * meterRslt.TestTime / tstRslt.TestTime;
-									}
-									else
-									{
-										meterRslt.VolumeRef = tstRslt.VolumeCTV;
-										meterRslt.PulsesMaster = tstRslt.PulsesMaster;
-									}
-
-									log.Info($"meterRslt.TimestampStart = {meterRslt.TimestampStart} \n" +
-									         $"meterRslt.TimestampEnd = {meterRslt.TimestampEnd }\n" +
-									         $"meterRslt.TestTime = {meterRslt.TestTime}\n" +
-									         $"meterRslt.VolumeStart = {meterRslt.VolumeStart}\n" +
-									         $"meterRslt.VolumeEnd = {meterRslt.VolumeEnd}\n" +
-									         $"meterRslt.VolumeMeter = {meterRslt.VolumeMeter}\n" +
-									         $"meterRslt.VolumeRef = {meterRslt.VolumeRef}\n" +
-									         $"meterRslt.PulsesMaster = {meterRslt.PulsesMaster}\n");
-									
-									
-								}
-								else
-								{
-									meterRslt.TimestampStart = dstrReader.TimestampSecStart;
-									meterRslt.TimestampEnd = !dstrReader.NoSamples
-										? dstrReader.TimestampSecEnd
-										: (dstrReader.TimestampSecStart + tstRslt.TestTime);
-									meterRslt.TestTime = meterRslt.TimestampEnd - meterRslt.TimestampStart;
-									meterRslt.VolumeStart = dstrReader.VolumeLtrStart; /// liter
+                                    meterRslt.VolumeMeter = poseidon.WMVolume;
+
+                                    if (!(meterRslt.TestTime == 0 || tstRslt.TestTime == 0))
+                                    {
+                                        meterRslt.VolumeRef = tstRslt.VolumeCTV * meterRslt.TestTime / tstRslt.TestTime;
+                                        meterRslt.PulsesMaster =
+                                            tstRslt.PulsesMaster * meterRslt.TestTime / tstRslt.TestTime;
+                                    }
+                                    else
+                                    {
+                                        meterRslt.VolumeRef = tstRslt.VolumeCTV;
+                                        meterRslt.PulsesMaster = tstRslt.PulsesMaster;
+                                    }
+
+                                    log.Info($"meterRslt.TimestampStart = {meterRslt.TimestampStart} \n" +
+                                             $"meterRslt.TimestampEnd = {meterRslt.TimestampEnd}\n" +
+                                             $"meterRslt.TestTime = {meterRslt.TestTime}\n" +
+                                             $"meterRslt.VolumeStart = {meterRslt.VolumeStart}\n" +
+                                             $"meterRslt.VolumeEnd = {meterRslt.VolumeEnd}\n" +
+                                             $"meterRslt.VolumeMeter = {meterRslt.VolumeMeter}\n" +
+                                             $"meterRslt.VolumeRef = {meterRslt.VolumeRef}\n" +
+                                             $"meterRslt.PulsesMaster = {meterRslt.PulsesMaster}\n");
+
+
+                                }
+                                else
+                                {
+                                    meterRslt.TimestampStart = dstrReader.TimestampSecStart;
+                                    meterRslt.TimestampEnd = !dstrReader.NoSamples
+                                        ? dstrReader.TimestampSecEnd
+                                        : (dstrReader.TimestampSecStart + tstRslt.TestTime);
+                                    meterRslt.TestTime = meterRslt.TimestampEnd - meterRslt.TimestampStart;
+                                    meterRslt.VolumeStart = dstrReader.VolumeLtrStart; /// liter
 									meterRslt.VolumeEnd = dstrReader.VolumeLtrEnd; /// liter
 									meterRslt.VolumeMeter =
-										Math.Abs(dstrReader.VolumeLtrEnd - dstrReader.VolumeLtrStart);
-									meterRslt.VolumeRef = tstRslt.VolumeCTV * meterRslt.TestTime / tstRslt.TestTime;
-									meterRslt.PulsesMaster =
-										tstRslt.PulsesMaster * meterRslt.TestTime / tstRslt.TestTime;
-								}
+                                        Math.Abs(dstrReader.VolumeLtrEnd - dstrReader.VolumeLtrStart);
+                                    meterRslt.VolumeRef = tstRslt.VolumeCTV * meterRslt.TestTime / tstRslt.TestTime;
+                                    meterRslt.PulsesMaster =
+                                        tstRslt.PulsesMaster * meterRslt.TestTime / tstRslt.TestTime;
+                                }
 
-								if (iPerl != null)
+                                if (iPerl != null)
                                 {
                                     if (iPerl.ResultCode != 0 && (meterRslt.WaterMeter.ResultCode & (int)Results.Entities.ResultCode.OptoErrorCodeMask) == 0)
                                     {
                                         meterRslt.WaterMeter.ResultCode |= iPerl.ResultCode;
                                     }
 #if IPERL
-								    meterRslt.WaterMeter.CalibFactor = iPerl.CalibFactor;
+                                    meterRslt.WaterMeter.CalibFactor = iPerl.CalibFactor;
                                     meterRslt.ExtraDataPath = iPerl.ExtraDataPath;
                                     if (TestMethods.iPerlCommunication.iPerlHead.IperlHead.FeatureVectorSize >= 1) meterRslt.X1 = iPerl.X[0];
                                     if (TestMethods.iPerlCommunication.iPerlHead.IperlHead.FeatureVectorSize >= 2) meterRslt.X2 = iPerl.X[1];
@@ -1005,18 +1064,18 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
                                                  meterRslt.VolumeMeter,
                                                  meterRslt.VolumeRef);
                             }
-							else if (cameraRoi != null)
-							{
-								meterRslt.TimestampStart = cameraRoi.TimestampStart;					/// [s]
-								meterRslt.TimestampEnd   = cameraRoi.TimestampEnd;						/// [s]
-								meterRslt.VolumeStart    = cameraRoi.VolumeStart;						/// [l]
-								meterRslt.VolumeEnd      = cameraRoi.VolumeEnd;							/// [l]
-								meterRslt.VolumeMeter    = cameraRoi.VolumeEnd - cameraRoi.VolumeStart;	/// [l]
+                            else if (cameraRoi != null)
+                            {
+                                meterRslt.TimestampStart = cameraRoi.TimestampStart;					/// [s]
+								meterRslt.TimestampEnd = cameraRoi.TimestampEnd;						/// [s]
+								meterRslt.VolumeStart = cameraRoi.VolumeStart;						/// [l]
+								meterRslt.VolumeEnd = cameraRoi.VolumeEnd;							/// [l]
+								meterRslt.VolumeMeter = cameraRoi.VolumeEnd - cameraRoi.VolumeStart;	/// [l]
 
                                 if (meterRslt.VolumeMeter != 0)
                                 {
                                     /// Normal measurement with camera
-                                    meterRslt.TestTime  = cameraRoi.TimestampEnd - cameraRoi.TimestampStart;	/// [s]
+                                    meterRslt.TestTime = cameraRoi.TimestampEnd - cameraRoi.TimestampStart;	/// [s]
                                     meterRslt.VolumeRef = tstRslt.VolumeCTV * meterRslt.TestTime / tstRslt.TestTime;
                                     meterRslt.PulsesMaster = tstRslt.PulsesMaster * meterRslt.TestTime / tstRslt.TestTime;
                                 }
@@ -1038,11 +1097,11 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
                                                  meterRslt.VolumeMeter,
                                                  meterRslt.VolumeRef);
                             }
-							else
-							{
+                            else
+                            {
                                 meterRslt.PulsesMaster = Convert.ToDouble(regReader.WMRefPulses);
                                 meterRslt.VolumeStart = 0;
-								meterRslt.VolumeEnd   = 0;
+                                meterRslt.VolumeEnd = 0;
                                 meterRslt.VolumeMeter = meterRslt.PulsesMeter * regReader.LtrsPerPulse;	/// [l]
 
                                 if (regReader.WMPulses >= 1)
@@ -1050,43 +1109,67 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
                                     /// Normal measurement
                                     meterRslt.TestTime = cBrd.TestTimeWM(regReader.Position);
                                     meterRslt.VolumeRef = meterRslt.PulsesMaster * tstRslt.ConstMaster;	/// [l]
+                                    meterRslt.MassRef = meterRslt.PulsesMaster * tstRslt.MassConstMaster;   /// [kg]
                                 }
                                 else
                                 {
                                     /// None or one pulse from the water meter
                                     meterRslt.TestTime = tstRslt.TestTime;
                                     meterRslt.VolumeRef = tstRslt.VolumeCTV;                            /// [l]
+                                    meterRslt.MassRef = tstRslt.MassCTV;
                                 }
 
-                                log.DebugFormat("Pulses: Pref4meter={0} Vmeter={1} Vref4meter={2} Ttime4meter={3} Ttime={4}",
+                                log.DebugFormat("Pulses: Pref4meter={0} Vmeter={1} Vref4meter={2} Mmeter={3} Mref4meter={4} Ttime4meter={5} Ttime={6}",
                                                  meterRslt.PulsesMaster,
                                                  meterRslt.VolumeMeter,
                                                  meterRslt.VolumeRef,
+                                                 meterRslt.MassMeter,
+                                                 meterRslt.MassRef,
                                                  meterRslt.TestTime,
                                                  tstRslt.TestTime);
                             }
 
-                            meterRslt.Error = Formulas.ErrorFromVolumes(meterRslt.VolumeMeter, meterRslt.VolumeRef);
-                            meterRslt.Passed = (meterRslt.Error >= test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime) + test.Uncertainty)
-											&& (meterRslt.Error <= test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime) - test.Uncertainty)
-                                            && (tstRslt.ErrorFlags == 0);
+                            double Error = 0;
+                            if (meterRslt.GetQuantityFromUnits() == "Mass")
+                                Error = Formulas.ErrorFromVolumes(meterRslt.MassMeter, meterRslt.MassRef);
+                            else
+                                Error = Formulas.ErrorFromVolumes(meterRslt.VolumeMeter, meterRslt.VolumeRef);
+
+                            meterRslt.Error = Error;
+
+                            var ErrLimLo_Volume = test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime);
+                            var ErrLimHi_Volume = test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime);
+                            var ErrLimLo_Mass = test.GetErrLimLo(tstRslt.MassCTV, tstRslt.TestTime);
+                            var ErrLimHi_Mass = test.GetErrLimHi(tstRslt.MassCTV, tstRslt.TestTime);
+
+                            bool Passed;
+                            if (meterRslt.GetQuantityFromUnits() == "Mass")
+                                Passed = (meterRslt.Error >= ErrLimLo_Volume + test.Uncertainty) &&
+                                (meterRslt.Error <= ErrLimHi_Volume - test.Uncertainty) &&
+                                (tstRslt.ErrorFlags == 0);
+                            else
+                                Passed = (meterRslt.Error >= ErrLimLo_Mass + test.Uncertainty) &&
+                                (meterRslt.Error <= ErrLimHi_Mass - test.Uncertainty) &&
+                                (tstRslt.ErrorFlags == 0);
+
+                            meterRslt.Passed = Passed;
                             meterRslt.TestDone = true;
                             tstRslt.TestDone = true;
 #if ORACLE_DB
                             meterRslt.ErrorBC = meterRslt.Error;
 #endif
                         }
-					}
-				}
-
-				tstRslt.Components = Results.Entities.Components.UpdateList(BatchRslts.ComponentsList,
-								new Results.Entities.Components((BenchInfo != null) ? BenchInfo.TestBenchId : 1,
-																(BenchInfo != null) ? BenchInfo.TestBenchName : "testbench",
-																inPath.Pump != null ? inPath.Pump.Name : string.Empty,
-																outPath.FlowMeter != null ? outPath.FlowMeter.Name : string.Empty,
-																cBrd.Devices.Scale.Name,
-																outPath.RegValve != null ? outPath.RegValve.Name : string.Empty,
-																outPath.Diverter != null ? outPath.Diverter.Name : string.Empty));
+                    }
+                }
+
+                tstRslt.Components = Results.Entities.Components.UpdateList(BatchRslts.ComponentsList,
+                                new Results.Entities.Components((BenchInfo != null) ? BenchInfo.TestBenchId : 1,
+                                                                (BenchInfo != null) ? BenchInfo.TestBenchName : "testbench",
+                                                                inPath.Pump != null ? inPath.Pump.Name : string.Empty,
+                                                                outPath.FlowMeter != null ? outPath.FlowMeter.Name : string.Empty,
+                                                                cBrd.Devices.Scale.Name,
+                                                                outPath.RegValve != null ? outPath.RegValve.Name : string.Empty,
+                                                                outPath.Diverter != null ? outPath.Diverter.Name : string.Empty));
 
                 /// Update water meter error flags
                 if (ErrorFlagsComp != null)
@@ -1105,24 +1188,24 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
                     }
                 }
 
-				/// Update results
-				Bridge.OnTestCompleted(this, new TestCompletedEventArgs(testName, tstRslt));
-			}
+                /// Update results
+                Bridge.OnTestCompleted(this, new TestCompletedEventArgs(testName, tstRslt));
+            }
 
-			Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.TransitionAfter));
+            Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.TransitionAfter));
 
-			/// Append the results to the CSV-file
-			allResults.Info(TestResult2CsvLine(testName, test.Part));
+            /// Append the results to the CSV-file
+            allResults.Info(TestResult2CsvLine(testName, test.Part));
 
             if (stopCycle) retVal = Event.ErrorFlagsStop;
 
-		stopTest:
+            stopTest:
 
-			StopRecordingStatistics();		/// Make sure graph files are closed
+            StopRecordingStatistics();      /// Make sure graph files are closed
 
-			///
-			///  Quit this sequence
-			///
+                                            ///
+                                            ///  Quit this sequence
+                                            ///
             if (isLastRepetition || retVal == Event.UiCmdStop
                                  || retVal == Event.OpArgumentError
                                  || retVal == Event.RecoverableError
@@ -1133,18 +1216,18 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
                 cBrd.StopAll(false);
             }
 
-			return new List<Event> { retVal };
-		}
+            return new List<Event> { retVal };
+        }
 
 
-		IList<Event> Simulate1(Config.Entities.Test test, int repetitionNr, bool isLastRepetition,
-							   Compound.CombinedTestParams compoundTestParams,
-							   HeatMeters.TestParams heatMetersTestParams)
-		{
-			///
-			/// Test method simulation
-			/// 
-			Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
+        IList<Event> Simulate1(Config.Entities.Test test, int repetitionNr, bool isLastRepetition,
+                               Compound.CombinedTestParams compoundTestParams,
+                               HeatMeters.TestParams heatMetersTestParams)
+        {
+            ///
+            /// Test method simulation
+            /// 
+            Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
 
             foreach (var rr in sensPath.RegisterReaders)
             {
@@ -1157,12 +1240,12 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
             StateMachine.WaitRunDevsRunOps();
             StateMachine.WaitRunDevsRunOps();
 
-            
-			if (compoundTestParams != null)
-			{
+
+            if (compoundTestParams != null)
+            {
                 if (test.Name.ToLower().Contains("nok")) MakeSimulatedCompound(test, 1, test.Part, 4.7f, 0.9f);
                 else MakeSimulatedCompound(test, repetitionNr, test.Part, 0.7f, 1.0f);
-			}
+            }
             else if (heatMetersTestParams != null)
             {
                 MakeSimulatedHeatMeters(test, repetitionNr, test.Part, 1.5f, 1000000, heatMetersTestParams.ErrorLimitLo, heatMetersTestParams.ErrorLimitHi, heatMetersTestParams.EvaluateVolume);
@@ -1170,91 +1253,91 @@ namespace TBF.Rig.TestMethods.FlyingStartMassCollection
             else
             {
                 float errorPctBase = -1.0f;
-				if (test.Name.ToLower().Contains("q3")) errorPctBase = -0.5f;
+                if (test.Name.ToLower().Contains("q3")) errorPctBase = -0.5f;
                 else if (test.Name.ToLower().Contains("q2")) errorPctBase = 0.5f;
                 else if (test.Name.ToLower().Contains("q1")) errorPctBase = -5.1f;
 
                 MakeSimulated(test, repetitionNr, test.Part, errorPctBase + repetitionNr * 0.1f);
             }
 
-			Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Completed));
-			Bridge.OnTestCompleted(this, new TestCompletedEventArgs(test.Name, BatchRslts.GetTestRslt(Results.Utils.GetTestName(test.Name, 1, 1), 0)));
-			allResults.Info(TestResult2CsvLine(test.Name, 0));	/// Append the results to the CSV-file
+            Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Completed));
+            Bridge.OnTestCompleted(this, new TestCompletedEventArgs(test.Name, BatchRslts.GetTestRslt(Results.Utils.GetTestName(test.Name, 1, 1), 0)));
+            allResults.Info(TestResult2CsvLine(test.Name, 0));  /// Append the results to the CSV-file
 
-			//-------------------------------------------------------------------
-			Bridge.OnActivity(this, string.Format("{0} Simulation", test.Name));
-			//-------------------------------------------------------------------
+            //-------------------------------------------------------------------
+            Bridge.OnActivity(this, string.Format("{0} Simulation", test.Name));
+            //-------------------------------------------------------------------
 
-			State.Create(string.Format("{0}({1}) : Simulation", test.Method, test.Name))
-					.AddOperation(checkUiOp)
-					.EnterState();
-			IList<Event> e = StateMachine.WaitRunDevsRunOps();
+            State.Create(string.Format("{0}({1}) : Simulation", test.Method, test.Name))
+                    .AddOperation(checkUiOp)
+                    .EnterState();
+            IList<Event> e = StateMachine.WaitRunDevsRunOps();
 
             return new List<Event> { TestAndLogUiCmdStop(test, e) ? Event.UiCmdStop : Event.Done };
-		}
+        }
 
 
-		IList<Event> Simulate2(Config.Entities.Test test, int repetitionNr, bool isLastRepetition,
-							   Compound.CombinedTestParams compoundTestParams,
-							   HeatMeters.TestParams heatMetersTestParams)
-		{
-			IList<Event> e;
-			Event retVal = Event.Done;
+        IList<Event> Simulate2(Config.Entities.Test test, int repetitionNr, bool isLastRepetition,
+                               Compound.CombinedTestParams compoundTestParams,
+                               HeatMeters.TestParams heatMetersTestParams)
+        {
+            IList<Event> e;
+            Event retVal = Event.Done;
 
-			///
-			/// Test method with flow chart simulation
-			/// 
-			Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
+            ///
+            /// Test method with flow chart simulation
+            /// 
+            Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
 
 
-			/// Simulate flow
+            /// Simulate flow
             StartNewStatistics(null, BatchRslts.Batch.BatchNr, test, repetitionNr, 0);
 
-			IntBox remainingTime = new IntBox((int)test.TestTime);
-			State.Create(string.Format("{0}({1}) : Simulation", test.Method, test.Name))
-				 .AddOperation(checkUiOp)
-				 .AddOperation(new Operations.TimerOp((int)test.TestTime, remainingTime))
-				 .EnterState();
-			do
-			{
-				e = StateMachine.WaitRunDevsRunOps();
-				if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; break; }
-
-				Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Test));
-
-				if (remainingTime.Val > 60)
-				{
-					Bridge.OnActivity(this, string.Format("{0} ... {1} {2} {3} {4}", Strings.Test_in_progress, remainingTime.Val / 60, "min", remainingTime.Val % 60, Strings.sec));
-				}
-				else
-				{
-					Bridge.OnActivity(this, string.Format("{0} ... {1} s", Strings.Test_in_progress, remainingTime.Val));
-				}
-				//------------------------------------------------
-
-				RefFlow.Val = (1.0 + 0.2 * Math.Sin(2 * Math.PI * (float)remainingTime.Val / test.TestTime)) * (test.QfromM3ph() + test.QtoM3ph()) / 2.0;
+            IntBox remainingTime = new IntBox((int)test.TestTime);
+            State.Create(string.Format("{0}({1}) : Simulation", test.Method, test.Name))
+                 .AddOperation(checkUiOp)
+                 .AddOperation(new Operations.TimerOp((int)test.TestTime, remainingTime))
+                 .EnterState();
+            do
+            {
+                e = StateMachine.WaitRunDevsRunOps();
+                if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; break; }
+
+                Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Test));
+
+                if (remainingTime.Val > 60)
+                {
+                    Bridge.OnActivity(this, string.Format("{0} ... {1} {2} {3} {4}", Strings.Test_in_progress, remainingTime.Val / 60, "min", remainingTime.Val % 60, Strings.sec));
+                }
+                else
+                {
+                    Bridge.OnActivity(this, string.Format("{0} ... {1} s", Strings.Test_in_progress, remainingTime.Val));
+                }
+                //------------------------------------------------
+
+                RefFlow.Val = (1.0 + 0.2 * Math.Sin(2 * Math.PI * (float)remainingTime.Val / test.TestTime)) * (test.QfromM3ph() + test.QtoM3ph()) / 2.0;
                 PressUp.Val = 2.7f;
                 PressDown.Val = 2.2f;
 
-				UpdateAllStatistics();
-			}
-			while (!e.Contains(Event.TimerExpired));
+                UpdateAllStatistics();
+            }
+            while (!e.Contains(Event.TimerExpired));
 
-			StopRecordingStatistics();
+            StopRecordingStatistics();
 
-			if (retVal != Event.UiCmdStop)
-			{
-				float errorPctBase = -1.0f;
+            if (retVal != Event.UiCmdStop)
+            {
+                float errorPctBase = -1.0f;
 
-				if      (test.Name.ToLower().Contains("q3")) errorPctBase = -0.5f;
-				else if (test.Name.ToLower().Contains("q2")) errorPctBase =  0.5f;
-				else if (test.Name.ToLower().Contains("q1")) errorPctBase = -5.1f;
+                if (test.Name.ToLower().Contains("q3")) errorPctBase = -0.5f;
+                else if (test.Name.ToLower().Contains("q2")) errorPctBase = 0.5f;
+                else if (test.Name.ToLower().Contains("q1")) errorPctBase = -5.1f;
 
-				MakeSimulated(test, repetitionNr, test.Part, errorPctBase + repetitionNr * 0.1f);
+                MakeSimulated(test, repetitionNr, test.Part, errorPctBase + repetitionNr * 0.1f);
 
-				Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Completed));
-				Bridge.OnTestCompleted(this, new TestCompletedEventArgs(test.Name, BatchRslts.GetTestRslt(Results.Utils.GetTestName(test.Name, 1, 1), 0)));
-				allResults.Info(TestResult2CsvLine(test.Name, 0));	/// Append the results to the CSV-file
+                Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Completed));
+                Bridge.OnTestCompleted(this, new TestCompletedEventArgs(test.Name, BatchRslts.GetTestRslt(Results.Utils.GetTestName(test.Name, 1, 1), 0)));
+                allResults.Info(TestResult2CsvLine(test.Name, 0));	/// Append the results to the CSV-file
 			}
 
             return new List<Event> { retVal };      /// default 'retVal' value is Event.Done
diff --git a/TBF/Rig/TestMethods/StandingStartMassCollection/StandingStartMassCollectionSeq.cs b/TBF/Rig/TestMethods/StandingStartMassCollection/StandingStartMassCollectionSeq.cs
--- a/TBF/Rig/TestMethods/StandingStartMassCollection/StandingStartMassCollectionSeq.cs
+++ b/TBF/Rig/TestMethods/StandingStartMassCollection/StandingStartMassCollectionSeq.cs
@@ -1,13 +1,14 @@
-///
+using Common;
+using Config.Entities;
+using log4net;
+///
 /// Copyright (c) 2013-2021 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Threading;
-using log4net;
-using Common;
-using Config.Entities;
+using System.Xml.Serialization;
 using TBF.Boxes;
 using TBF.Resources;
 using TBF.Rig.GenericDevices;
@@ -74,21 +75,21 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
             return true;
         }
 
-		/// <summary>
-		/// Fixed start mass collection method sequence
-		/// </summary>
-		/// <param name="test">Test entity</param>
-		/// <returns>
-		///		Event.Done . . . . . . . OK
-		///		Event.MakeSecondPass . . OK, 2nd pass (=evaluation) required
-		///		Event.UiCmdStop  . . . . Stopped by the user using the on-screen button STOP
-		///		Event.OpArgumentError  . Target flow is out of range
-		///		Event.Error  . . . . . . Unspecified error
-		/// </returns>
-		public IList<Event> Execute(Config.Entities.Test test, int repetitionNr, bool isLastRepetition,
+        /// <summary>
+        /// Fixed start mass collection method sequence
+        /// </summary>
+        /// <param name="test">Test entity</param>
+        /// <returns>
+        ///		Event.Done . . . . . . . OK
+        ///		Event.MakeSecondPass . . OK, 2nd pass (=evaluation) required
+        ///		Event.UiCmdStop  . . . . Stopped by the user using the on-screen button STOP
+        ///		Event.OpArgumentError  . Target flow is out of range
+        ///		Event.Error  . . . . . . Unspecified error
+        /// </returns>
+        public IList<Event> Execute(Config.Entities.Test test, int repetitionNr, bool isLastRepetition,
                                     bool compound,
-									HeatMeters.TestParams heatMetersTestParams,
-									Common.DebugMode debugLevel)
+                                    HeatMeters.TestParams heatMetersTestParams,
+                                    Common.DebugMode debugLevel)
         {
             ControlBoard.IControlBoard cBrd = StateMachine.ControlBoardMain;
             IScale scale = cBrd.Devices.Scale as IScale;
@@ -101,7 +102,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
             }
 
             IList<Event> e;                                 /// Events from currently running operations
-            int waterMetersCount = Math.Min(BenchInfo.WaterMetersCount, sensPath.RegisterReaders.Length);                                                            
+            int waterMetersCount = Math.Min(BenchInfo.WaterMetersCount, sensPath.RegisterReaders.Length);
             DateTimeBox timeStampStart = new DateTimeBox();
             DateTimeBox timeStampEnd = new DateTimeBox();
             FloatBox startSwitchTime = new FloatBox();
@@ -154,7 +155,8 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                  .AddOperation(checkUiOp)
                  .AddOperations(readTempPressOps)
                  .EnterState();
-            do {
+            do
+            {
                 e = StateMachine.WaitRunDevsRunOps();
                 if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
                 if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
@@ -172,53 +174,54 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
             IOperation heatMetersPromptOp = null;
             if (heatMetersTestParams != null && !string.IsNullOrEmpty(heatMetersTestParams.Prompt))
             {
-				/// Make sure the CycleBeginForm is closed
-				if (UIFlowControl.Stop == WaitBeginFormClosed()) goto stopTest;
+                /// Make sure the CycleBeginForm is closed
+                if (UIFlowControl.Stop == WaitBeginFormClosed()) goto stopTest;
 
-				heatMetersPromptOp = new Operations.MessageBoxOp(heatMetersTestParams.Prompt);
+                heatMetersPromptOp = new Operations.MessageBoxOp(heatMetersTestParams.Prompt);
             }
 
 
             if (test.DoDraining || (scale.Mass + test.Volume >= scale.Capacity * Constants.TankFullFactor))
-			{
+            {
                 ///
                 /// There is not enough room in the tank OR unconditional draining ... drain the water tank
                 ///
                 IList<IOperation> ops = new List<IOperation>(readTempPressOps);
                 ops.Add(heatMetersPromptOp);
-				switch (DrainTheTank(scale, ops))
-				{
-					case Event.Error:	  { retVal = Event.Error;	  goto stopTest; }
-					case Event.UiCmdStop: { retVal = Event.UiCmdStop; goto stopTest; }
-				}
-			}
-			///
-			/// Make sure the drain valve is closed
-			///
-			State.Create(string.Format("{0}({1}) : Make sure the drain valve is closed", test.Method, test.Name))
-				 .AddOperation(checkUiOp)
+                switch (DrainTheTank(scale, ops))
+                {
+                    case Event.Error: { retVal = Event.Error; goto stopTest; }
+                    case Event.UiCmdStop: { retVal = Event.UiCmdStop; goto stopTest; }
+                }
+            }
+            ///
+            /// Make sure the drain valve is closed
+            ///
+            State.Create(string.Format("{0}({1}) : Make sure the drain valve is closed", test.Method, test.Name))
+                 .AddOperation(checkUiOp)
                  .AddOperations(readTempPressOps)
-				 .AddOperation(heatMetersPromptOp)
-				 .AddOperation(cBrd.SetValvesOp(null, scale.DrainValve))
-				 .EnterState();
-			do {
-				e = StateMachine.WaitRunDevsRunOps();
-				Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.JustStarted));
+                 .AddOperation(heatMetersPromptOp)
+                 .AddOperation(cBrd.SetValvesOp(null, scale.DrainValve))
+                 .EnterState();
+            do
+            {
+                e = StateMachine.WaitRunDevsRunOps();
+                Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.JustStarted));
 
-				if (e.Contains(Event.Error))	  { retVal = Event.Error;	  goto stopTest; }
-				if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
-			}
-			while (!e.Contains(Event.ValvesSet));
+                if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+                if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
+            }
+            while (!e.Contains(Event.ValvesSet));
 
 
             //------------------------------------------------
             Bridge.OnActivity(this, Strings.Starting_the_pump);
             //------------------------------------------------
 
-			Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
-			int flowSetTime0 = StateMachine.Time;
+            Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
+            int flowSetTime0 = StateMachine.Time;
 
-			if (inPath.Pump is GenericDevices.IPumpFM) (inPath.Pump as GenericDevices.IPumpFM).TurnOn(test.PumpPower);
+            if (inPath.Pump is GenericDevices.IPumpFM) (inPath.Pump as GenericDevices.IPumpFM).TurnOn(test.PumpPower);
             ///
             State.Create(string.Format("{0}({1}) : Starting the pump", test.Method, test.Name))
                  .AddOperation(checkUiOp)
@@ -227,14 +230,15 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                  .AddOperation(heatMetersPromptOp)
                  .AddOperation(inPath.Pump != null ? cBrd.SetValvesOp(inPath.Pump, null) : null)
                  .EnterState();
-            do {
+            do
+            {
                 e = StateMachine.WaitRunDevsRunOps();
                 Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
 
                 if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
-                if (e.Contains(Event.Error))      { retVal = Event.Error;     goto stopTest; }
+                if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
             }
-			while (e.Contains(Event.ValvesBusy) /* || !e.Contains(Event.AllPositionsReached)*/);
+            while (e.Contains(Event.ValvesBusy) /* || !e.Contains(Event.AllPositionsReached)*/);
 
 
             if (test.TimePump2StartV > 0)
@@ -245,7 +249,8 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                      .AddOperation(new Operations.TimerOp(test.TimePump2StartV))
                      .AddOperation(heatMetersPromptOp)
                      .EnterState();
-                do {
+                do
+                {
                     e = StateMachine.WaitRunDevsRunOps();
                     Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
 
@@ -263,10 +268,11 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                      .AddOperation(cBrd.SetValvesOp(benchPath.StopBFValve, null))
                      .AddOperation(heatMetersPromptOp)
                      .EnterState();
-                do {
+                do
+                {
                     e = StateMachine.WaitRunDevsRunOps();
                     if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
-                    if (e.Contains(Event.Error))      { retVal = Event.Error;     goto stopTest; }
+                    if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
                 }
                 while (!e.Contains(Event.ValvesSet));
             }
@@ -280,7 +286,8 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                      .AddOperation(new Operations.TimerOp(test.TimeBeforeFlow))
                      .AddOperation(heatMetersPromptOp)
                      .EnterState();
-                do {
+                do
+                {
                     e = StateMachine.WaitRunDevsRunOps();
                     Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
 
@@ -302,8 +309,9 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                  .AddOperations(readTempPressOps)
                  .AddOperation(cBrd.SetValvesOp(inPath.Pump, null))
                  .AddOperation(heatMetersPromptOp)
-				 .EnterState();
-            do {
+                 .EnterState();
+            do
+            {
                 e = StateMachine.WaitRunDevsRunOps();
                 Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
 
@@ -317,7 +325,8 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                  .AddOperation(cBrd.OpenStartValveOp())
                  .AddOperation(heatMetersPromptOp)
                  .EnterState();
-            do {
+            do
+            {
                 e = StateMachine.WaitRunDevsRunOps();
                 Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
 
@@ -329,14 +338,15 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                  .AddOperation(checkUiOp)
                  .AddOperations(readTempPressOps)
                  .AddOperation(cBrd.SetFlowOp(test.QfromM3ph(), test.QtoM3ph(), RefFlow, FlowSettingTimeoutSec))
-				 .AddOperation(heatMetersPromptOp)
-				 .EnterState();
-            do {
+                 .AddOperation(heatMetersPromptOp)
+                 .EnterState();
+            do
+            {
                 e = StateMachine.WaitRunDevsRunOps();
                 Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.FlowSetting));
 
                 if (e.Contains(Event.OpArgumentError)) { retVal = Event.OpArgumentError; goto stopTest; }
-                if (TestAndLogUiCmdStop(test, e))      { retVal = Event.UiCmdStop;       goto stopTest; }
+                if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
                 if (e.Contains(Event.RegulValveTimeOut))
                 {
                     Bridge.OnError(this, Strings.Flow_adjustment_failed);
@@ -362,15 +372,16 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                 //---------------------------------------------------
 
                 int lastTimeSec = StateMachine.Time;
-				double Tw_last = 0;
-				double Tc_last = 0;
+                double Tw_last = 0;
+                double Tc_last = 0;
 
                 State.Create(string.Format("{0}({1}) : Checking if the temperature is stable", test.Method, test.Name))
                      .AddOperation(checkUiOp)
                      .AddOperations(readTempPressOps)
-					 .AddOperation(heatMetersPromptOp)
-					 .EnterState();
-                do {
+                     .AddOperation(heatMetersPromptOp)
+                     .EnterState();
+                do
+                {
                     e = StateMachine.WaitRunDevsRunOps();
                     if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
                     if (e.Contains(Event.Next))
@@ -378,56 +389,57 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                         break;          /// Simulate temperature is within range
                     }
 
-					if (TempRefHi1.Val != 0 && TempRefHi2.Val != 0 && TempRefLo1.Val != 0 && TempRefLo2.Val != 0)
-					{
-						if (StateMachine.Time - lastTimeSec > 10 || StateMachine.Time - lastTimeSec < 0)
-						{
-							double Tw = (TempRefHi1.Val + TempRefHi2.Val) / 2;
-							double Tc = (TempRefLo1.Val + TempRefLo2.Val) / 2;
-							if ((heatMetersTestParams.TempWarmLo <= Tw) && (Tw <= heatMetersTestParams.TempWarmHi) &&
-								(heatMetersTestParams.TempColdLo <= Tc) && (Tc <= heatMetersTestParams.TempColdHi) &&
-								(Math.Abs(Tw - Tw_last) <= heatMetersTestParams.ChangeInTimeWarm) &&
-								(Math.Abs(Tc - Tc_last) <= heatMetersTestParams.ChangeInTimeCold) &&
-								(Math.Abs(TempRefHi1.Val - TempRefHi2.Val) <= heatMetersTestParams.DeltaTempWarm) &&
-								(Math.Abs(TempRefLo1.Val - TempRefLo2.Val) <= heatMetersTestParams.DeltaTempCold))
-							{
+                    if (TempRefHi1.Val != 0 && TempRefHi2.Val != 0 && TempRefLo1.Val != 0 && TempRefLo2.Val != 0)
+                    {
+                        if (StateMachine.Time - lastTimeSec > 10 || StateMachine.Time - lastTimeSec < 0)
+                        {
+                            double Tw = (TempRefHi1.Val + TempRefHi2.Val) / 2;
+                            double Tc = (TempRefLo1.Val + TempRefLo2.Val) / 2;
+                            if ((heatMetersTestParams.TempWarmLo <= Tw) && (Tw <= heatMetersTestParams.TempWarmHi) &&
+                                (heatMetersTestParams.TempColdLo <= Tc) && (Tc <= heatMetersTestParams.TempColdHi) &&
+                                (Math.Abs(Tw - Tw_last) <= heatMetersTestParams.ChangeInTimeWarm) &&
+                                (Math.Abs(Tc - Tc_last) <= heatMetersTestParams.ChangeInTimeCold) &&
+                                (Math.Abs(TempRefHi1.Val - TempRefHi2.Val) <= heatMetersTestParams.DeltaTempWarm) &&
+                                (Math.Abs(TempRefLo1.Val - TempRefLo2.Val) <= heatMetersTestParams.DeltaTempCold))
+                            {
                                 break;          /// Temperature is withing required range
 							}
 
-							lastTimeSec = StateMachine.Time;
-							Tw_last = Tw;
-							Tc_last = Tc;
-						}
-					}
+                            lastTimeSec = StateMachine.Time;
+                            Tw_last = Tw;
+                            Tc_last = Tc;
+                        }
+                    }
                 }
                 while (true);
             }
-			else if (!string.IsNullOrEmpty(test.TempControl) && benchPath.TempMtrUp != null && benchPath.TempMtrDown != null)
-			{
-				//---------------------------------------------------
-				Bridge.OnActivity(this, Strings.Setting_temperature);
-				//---------------------------------------------------
-
-				State.Create(string.Format("{0}({1}) : Wait until the water temperature is within limits", test.Method, test.Name))
-					 .AddOperation(checkUiOp)
+            else if (!string.IsNullOrEmpty(test.TempControl) && benchPath.TempMtrUp != null && benchPath.TempMtrDown != null)
+            {
+                //---------------------------------------------------
+                Bridge.OnActivity(this, Strings.Setting_temperature);
+                //---------------------------------------------------
+
+                State.Create(string.Format("{0}({1}) : Wait until the water temperature is within limits", test.Method, test.Name))
+                     .AddOperation(checkUiOp)
                      .AddOperations(readTempPressOps)
-					 .EnterState();
-				do {
-					e = StateMachine.WaitRunDevsRunOps();
-					if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
+                     .EnterState();
+                do
+                {
+                    e = StateMachine.WaitRunDevsRunOps();
+                    if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
                     if (e.Contains(Event.Next))
                     {
                         break;          /// Simulate temperature is within range
                     }
 
-					if (TempUp.Val >= test.TempLimLo && TempUp.Val <= test.TempLimHi &&
-						TempDown.Val >= test.TempLimLo && TempDown.Val <= test.TempLimHi)
-					{
+                    if (TempUp.Val >= test.TempLimLo && TempUp.Val <= test.TempLimHi &&
+                        TempDown.Val >= test.TempLimLo && TempDown.Val <= test.TempLimHi)
+                    {
                         break;          /// Temperature set withing required range
                     }
-				}
-				while (true);
-			}
+                }
+                while (true);
+            }
 
             ///
             /// Temperature is withing required range at this point
@@ -435,7 +447,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
 
             //-----------------------------------------------------------------
             Bridge.OnActivity(this, Strings.Stopping_flow_for_the_fixed_start);
-			//-----------------------------------------------------------------
+            //-----------------------------------------------------------------
             State.Create(string.Format("{0}({1}) : Stop flow regulation", test.Method, test.Name))
                  .AddOperation(checkUiOp)
                  .AddOperations(readTempPressOps)
@@ -451,10 +463,11 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                  .AddOperation(checkUiOp)
                  .AddOperations(readTempPressOps)
                  .AddOperation(cBrd.CloseStartValveOp())
-				 .EnterState();
-            do {
+                 .EnterState();
+            do
+            {
                 e = StateMachine.WaitRunDevsRunOps();
-                if (e.Contains(Event.Error))      { retVal = Event.Error;     goto stopTest; }
+                if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
                 if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
             }
             while (!e.Contains(Event.ValvesSet));
@@ -483,10 +496,10 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
             if (heatMetersPath == null) LogProcessDataHeader(processDataLogger, "Start mass");
             else LogProcessDataHeaderHeatMeters(processDataLogger, "Start mass");
 
-			///
-			/// Enter water meter begin states and read the start mass at the same time
-			///
-			GenericDevices.IHasWMStatesForm dataEntryCmpnt = TbfComponents.FindComponent(StateMachine.Procedure.DataEntry) as GenericDevices.IHasWMStatesForm;
+            ///
+            /// Enter water meter begin states and read the start mass at the same time
+            ///
+            GenericDevices.IHasWMStatesForm dataEntryCmpnt = TbfComponents.FindComponent(StateMachine.Procedure.DataEntry) as GenericDevices.IHasWMStatesForm;
             IOperation readStartMassOp = scale.ReadStableMassOp(ref StartMass, test.TimeFlow2Mass, test.MassMethod, test.MassRepeats, test.MassSpread);
 
             if (dataEntryCmpnt != null)
@@ -515,7 +528,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                             triggerValve = roi.GetValve();
                             if (triggerValve != null && !triggerSend)
                             {
-                                OpenValveGrabImage(cBrd,testInProgress, triggerValve, e,
+                                OpenValveGrabImage(cBrd, testInProgress, triggerValve, e,
                                     string.Format("{0}({1}) : Grabbing images - valve open", test.Method, test.Name));
                                 triggerSend = true;
                             }
@@ -533,27 +546,28 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                         }
                     }
                     state2.EnterState();
-                    do {
+                    do
+                    {
                         e = StateMachine.WaitRunDevsRunOps();
 
                         Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Test));
 
-                        if (e.Contains(Event.Error))      { retVal = Event.Error;     break; }
+                        if (e.Contains(Event.Error)) { retVal = Event.Error; break; }
                         if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; break; }
                     }
                     while (e.Contains(Event.CameraBusy));
 
                     (dataEntryCmpnt as GenericDevices.IDataEntryForCamera).StartImages = startImages;
                 }
-                
+
                 ///valve trigger camera close
                 if (triggerValve != null)
                 {
-                    CloseValveGrabImage(cBrd,testInProgress,triggerValve, e,
+                    CloseValveGrabImage(cBrd, testInProgress, triggerValve, e,
                         string.Format("{0}({1}) : Grabbing images - valve close", test.Method, test.Name));
                 }
                 ///////
-                
+
 
                 Bridge.OnActivity(this, Strings.Enter_water_meter_data);
                 long readStartTime = StateMachine.Time;
@@ -564,13 +578,14 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                      .AddOperation((dataEntryCmpnt as GenericDevices.IHasWMStatesForm).ShowTestStartFormOp(sensPath.RegisterReaders))
                      .AddOperation(processDataLoggingOp)
                      .EnterState();
-                do {
+                do
+                {
                     e = StateMachine.WaitRunDevsRunOps();
                     if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
                 }
                 while (!e.Contains(Event.ModelessFormClosed));
                 long readEndTime = StateMachine.Time;
-                
+
                 log.Debug("Read poseidon - took:" + (readEndTime - readStartTime));
 
                 if (heatMetersTestParams != null)
@@ -612,7 +627,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                         {
                             (rr as Rig.Network.Camera.RoiForFixedStartKeyence.Roi).BeginWMState =
                                 dataEntryCmpnt.WMStartState(i);
-                            log.DebugFormat(" StandingStartMassCollectionSeq.cs - BeginWMState [{0}] -> RoiForFixedStartKeyence.Roi",dataEntryCmpnt.WMStartState(i));
+                            log.DebugFormat(" StandingStartMassCollectionSeq.cs - BeginWMState [{0}] -> RoiForFixedStartKeyence.Roi", dataEntryCmpnt.WMStartState(i));
                         }
                         if (rr is Rig.Network.Camera.RoiForFixedStartCJMS11.Roi)
                             (rr as Rig.Network.Camera.RoiForFixedStartCJMS11.Roi).BeginWMState = dataEntryCmpnt.WMStartState(i);
@@ -638,7 +653,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                                     string destFName = string.IsNullOrEmpty((dataEntryCmpnt as IDataEntryForCamera).TestStartImgName(i, testName))
                                         ? fileName : (dataEntryCmpnt as IDataEntryForCamera).TestStartImgName(i, testName);
                                     File.Copy(Path.Combine(srcDir, fileName), Path.Combine(destDir, destFName), true);
-                                    log.DebugFormat("Save images sourceFile: {0}, destFile: {1} ",Path.Combine(srcDir, fileName), Path.Combine(destDir, destFName));
+                                    log.DebugFormat("Save images sourceFile: {0}, destFile: {1} ", Path.Combine(srcDir, fileName), Path.Combine(destDir, destFName));
                                 }
                             }
                             catch (Exception exc)
@@ -681,7 +696,8 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                      .AddOperation(scale.ReadStableMassOp(ref StartMass, test.TimeFlow2Mass, test.MassMethod, test.MassRepeats, test.MassSpread))
                      .AddOperation(processDataLoggingOp)
                      .EnterState();
-                do {
+                do
+                {
                     e = StateMachine.WaitRunDevsRunOps();
                     if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
                     if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
@@ -724,11 +740,12 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                  .AddOperation(controlFlowOp)
                  .AddOperation(processDataLoggingOp)
                  .EnterState();
-            do {
+            do
+            {
                 e = StateMachine.WaitRunDevsRunOps();
                 if (e.Contains(Event.OpArgumentError)) { retVal = Event.OpArgumentError; goto stopTest; }
-                if (e.Contains(Event.Error))           { retVal = Event.Error;           goto stopTest; }
-                if (TestAndLogUiCmdStop(test, e))      { retVal = Event.UiCmdStop;       goto stopTest; }
+                if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
+                if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
 
                 /// Show remaining time
                 if ((remainingTime = Math.Max(estimtdEndTime - StateMachine.Time, 0)) > 60)
@@ -767,8 +784,8 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
 
                 Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Test));
             }
-            while ((cBrd.DebugLevel==DebugMode.Simulate && !e.Contains(Event.FlowReached)) || 
-                   (cBrd.DebugLevel!=DebugMode.Simulate && cBrd.RefPulses < initialPulsesCount + totalPulses && !e.Contains(Event.TestCompleted) && !e.Contains(Event.Next)));
+            while ((cBrd.DebugLevel == DebugMode.Simulate && !e.Contains(Event.FlowReached)) ||
+                   (cBrd.DebugLevel != DebugMode.Simulate && cBrd.RefPulses < initialPulsesCount + totalPulses && !e.Contains(Event.TestCompleted) && !e.Contains(Event.Next)));
 
             /// Measurement loop end
             log.WarnFormat("Start valve switch time on test start = {0} ms", cBrd.ValveOpenCloseTime);
@@ -783,7 +800,8 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                  .AddOperation(cBrd.CloseStartValveOp(timeStampEnd, stopSwitchTime))
                  .AddOperation(processDataLoggingOp)
                  .EnterState();
-            do {
+            do
+            {
                 e = StateMachine.WaitRunDevsRunOps();
                 if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
             }
@@ -807,9 +825,10 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                  .AddOperation(new Operations.TimerOp(StableMassMsrmntTimeoutSec))
                  .AddOperation(processDataLoggingOp)
                  .EnterState();
-            do {
+            do
+            {
                 e = StateMachine.WaitRunDevsRunOps();
-                if (e.Contains(Event.Error))      { retVal = Event.Error;     goto stopTest; }
+                if (e.Contains(Event.Error)) { retVal = Event.Error; goto stopTest; }
                 if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
                 if (e.Contains(Event.ScaleTimeout))
                 {
@@ -844,7 +863,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
             double buoyancy = Formulas.Buoyancy();
             double massOfEvaporatedWater = (double)(tMass2 - tMass1) * outPath.Scale.EvaporationRate(TempDivStat.Average);
             double volumeCTV = 1000.0 * buoyancy * (massEnd - massStart + massOfEvaporatedWater) / densityOut;
-			if (debugLevel == Common.DebugMode.Simulate) volumeCTV = test.Volume;
+            if (debugLevel == Common.DebugMode.Simulate) volumeCTV = test.Volume;
 
             double refEnergy = Energy.Sum * volumeCTV / VolumeForEnergy.Sum;					/// [J]=[J]*[l]/[l]
 
@@ -853,33 +872,33 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
             ///
             if (dataEntryCmpnt != null)
             {
-				string fileName = string.Format("{0}-{1}-end.bmp", test.Name, repetitionNr); //string.Format("{0}-end.bmp", test.Name);
-                
+                string fileName = string.Format("{0}-{1}-end.bmp", test.Name, repetitionNr); //string.Format("{0}-end.bmp", test.Name);
+
                 IValve triggerValve = null;
                 bool triggerSend = false;
-				if (dataEntryCmpnt is GenericDevices.IDataEntryForCamera)
-				{
-					string[] endImages = new string[sensPath.RegisterReaders.Length];
-
-					State state2 = State.Create(string.Format("{0}({1}) : Grabbing images", test.Method, test.Name))
-									   .AddOperation(checkUiOp);
-					for (int i = 0; i < sensPath.RegisterReaders.Length; i++)
-					{
-						GenericDevices.IRegReaderStillCamera roi = sensPath.RegisterReaders[i] as GenericDevices.IRegReaderStillCamera;
-						if (roi != null)
-						{
+                if (dataEntryCmpnt is GenericDevices.IDataEntryForCamera)
+                {
+                    string[] endImages = new string[sensPath.RegisterReaders.Length];
+
+                    State state2 = State.Create(string.Format("{0}({1}) : Grabbing images", test.Method, test.Name))
+                                       .AddOperation(checkUiOp);
+                    for (int i = 0; i < sensPath.RegisterReaders.Length; i++)
+                    {
+                        GenericDevices.IRegReaderStillCamera roi = sensPath.RegisterReaders[i] as GenericDevices.IRegReaderStillCamera;
+                        if (roi != null)
+                        {
                             ///if exist valve trigger camera open
                             triggerValve = roi.GetValve();
                             if (triggerValve != null && !triggerSend)
                             {
-                                OpenValveGrabImage(cBrd,testInProgress,triggerValve, e,
+                                OpenValveGrabImage(cBrd, testInProgress, triggerValve, e,
                                     string.Format("{0}({1}) : Grabbing images - valve open", test.Method, test.Name));
                                 triggerSend = true;
                             }
-							string directory = Path.Combine(Program.TempImagesDir, BatchRslts.Batch.BatchNr.ToString(), (i + 1).ToString());
-							Directory.CreateDirectory(directory);
-							endImages[i] = Path.Combine(directory, fileName);
-							state2.AddOperation(roi.GrabImageOp(endImages[i]));
+                            string directory = Path.Combine(Program.TempImagesDir, BatchRslts.Batch.BatchNr.ToString(), (i + 1).ToString());
+                            Directory.CreateDirectory(directory);
+                            endImages[i] = Path.Combine(directory, fileName);
+                            state2.AddOperation(roi.GrabImageOp(endImages[i]));
                             state2.AddOperation(testInProgress);
                         }
                         else
@@ -890,47 +909,49 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                             endImages[i] = Path.Combine(directory, fileName);
                         }
                     }
-					state2.EnterState();
-					do {
-						e = StateMachine.WaitRunDevsRunOps();
+                    state2.EnterState();
+                    do
+                    {
+                        e = StateMachine.WaitRunDevsRunOps();
+
+                        Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Test));
 
-						Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetitionNr, Progress.Test));
+                        if (e.Contains(Event.Error)) { retVal = Event.Error; break; }
+                        if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; break; }
+                    }
+                    while (e.Contains(Event.CameraBusy));
 
-						if (e.Contains(Event.Error)) { retVal = Event.Error; break; }
-						if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; break; }
-					}
-					while (e.Contains(Event.CameraBusy));
+                    (dataEntryCmpnt as GenericDevices.IDataEntryForCamera).EndImages = endImages;
+                }
 
-					(dataEntryCmpnt as GenericDevices.IDataEntryForCamera).EndImages = endImages;
-				}
-                
                 ///valve trigger camera close
                 if (triggerValve != null)
                 {
-                    CloseValveGrabImage(cBrd,testInProgress, triggerValve, e,
+                    CloseValveGrabImage(cBrd, testInProgress, triggerValve, e,
                         string.Format("{0}({1}) : Grabbing images - valve close", test.Method, test.Name));
                 }
                 ///////
-                
-				Bridge.OnActivity(this, Strings.Enter_water_meter_data);
+
+                Bridge.OnActivity(this, Strings.Enter_water_meter_data);
                 State state = State.Create(string.Format("{0}({1}) : Entering the end-state", test.Method, test.Name));
                 if (heatMetersTestParams != null && dataEntryCmpnt is GenericDevices.IHasHeatMtrStatesForm)
                 {
                     state.AddOperation((dataEntryCmpnt as GenericDevices.IHasHeatMtrStatesForm).
-						ShowTestEndFormOp(sensPath.RegisterReaders,
-										  volumeCTV, test.ErrLimLo + test.Uncertainty, test.ErrLimHi - test.Uncertainty,
+                        ShowTestEndFormOp(sensPath.RegisterReaders,
+                                          volumeCTV, test.ErrLimLo + test.Uncertainty, test.ErrLimHi - test.Uncertainty,
                                           refEnergy, test.ErrLimLo + test.Uncertainty, test.ErrLimHi - test.Uncertainty));
                 }
                 else
                 {
-					state.AddOperation(dataEntryCmpnt.ShowTestEndFormOp(sensPath.RegisterReaders,
-																	    volumeCTV, test.ErrLimLo + test.Uncertainty, test.ErrLimHi - test.Uncertainty));
+                    state.AddOperation(dataEntryCmpnt.ShowTestEndFormOp(sensPath.RegisterReaders,
+                                                                        volumeCTV, test.ErrLimLo + test.Uncertainty, test.ErrLimHi - test.Uncertainty));
                 }
                 state.AddOperation(checkUiOp)
                      .AddOperations(readTempPressOps)
                      .AddOperation(testInProgress)
                      .EnterState();
-                do {
+                do
+                {
                     e = StateMachine.WaitRunDevsRunOps();
                     if (TestAndLogUiCmdStop(test, e)) { retVal = Event.UiCmdStop; goto stopTest; }
                 }
@@ -958,41 +979,41 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                 {
                     for (int i = 0; i < waterMetersCount; i++)
                     {
-						GenericDevices.IRegReader rr = sensPath.RegisterReaders[i];
-                        
+                        GenericDevices.IRegReader rr = sensPath.RegisterReaders[i];
+
                         if (rr is ICommonRegReader)
                             (rr as ICommonRegReader).EndWMState = dataEntryCmpnt.WMEndState(i);
 
 
-						if (rr is Rig.RegisterReaders.StandingStartStop.RegisterReader)
-							(rr as Rig.RegisterReaders.StandingStartStop.RegisterReader).EndWMState = dataEntryCmpnt.WMEndState(i);
+                        if (rr is Rig.RegisterReaders.StandingStartStop.RegisterReader)
+                            (rr as Rig.RegisterReaders.StandingStartStop.RegisterReader).EndWMState = dataEntryCmpnt.WMEndState(i);
 
-						if (rr is Rig.Network.Camera.RoiForFixedStart.Roi)
-							(rr as Rig.Network.Camera.RoiForFixedStart.Roi).EndWMState = dataEntryCmpnt.WMEndState(i);
+                        if (rr is Rig.Network.Camera.RoiForFixedStart.Roi)
+                            (rr as Rig.Network.Camera.RoiForFixedStart.Roi).EndWMState = dataEntryCmpnt.WMEndState(i);
 
                         if (rr is Rig.Network.Camera.RoiForFixedStartKeyence.Roi)
                         {
                             (rr as Rig.Network.Camera.RoiForFixedStartKeyence.Roi).EndWMState =
                                 dataEntryCmpnt.WMEndState(i);
-                            log.DebugFormat(" StandingStartMassCollectionSeq.cs - EndWMState [{0}] -> RoiForFixedStartKeyence.Roi",dataEntryCmpnt.WMEndState(i));
+                            log.DebugFormat(" StandingStartMassCollectionSeq.cs - EndWMState [{0}] -> RoiForFixedStartKeyence.Roi", dataEntryCmpnt.WMEndState(i));
                         }
-                        if(rr is Rig.Network.Camera.RoiForFixedStartCJMS11.Roi)
+                        if (rr is Rig.Network.Camera.RoiForFixedStartCJMS11.Roi)
                             (rr as Rig.Network.Camera.RoiForFixedStartCJMS11.Roi).EndWMState = dataEntryCmpnt.WMEndState(i);
 
                     }
                 }
 
-				if (dataEntryCmpnt is IDataEntryForCamera && (dataEntryCmpnt as IDataEntryForCamera).SaveImages)
-				{
+                if (dataEntryCmpnt is IDataEntryForCamera && (dataEntryCmpnt as IDataEntryForCamera).SaveImages)
+                {
                     log.Debug("Save images  EndWMState...");
-					/// SaveImages==true ... copy images to the directory that will be archived at the end of the cycle
-					for (int i = 0; i < sensPath.RegisterReaders.Length; i++)
-					{
-						var roi = sensPath.RegisterReaders[i] as IRegReaderStillCamera;
-						if (roi != null)
-						{
-							string srcDir = Path.Combine(Program.TempImagesDir, BatchRslts.Batch.BatchNr.ToString(), (i + 1).ToString());
-							string destDir = Path.Combine(Program.ImagesDir, BatchRslts.Batch.BatchNr.ToString(), (i + 1).ToString());
+                    /// SaveImages==true ... copy images to the directory that will be archived at the end of the cycle
+                    for (int i = 0; i < sensPath.RegisterReaders.Length; i++)
+                    {
+                        var roi = sensPath.RegisterReaders[i] as IRegReaderStillCamera;
+                        if (roi != null)
+                        {
+                            string srcDir = Path.Combine(Program.TempImagesDir, BatchRslts.Batch.BatchNr.ToString(), (i + 1).ToString());
+                            string destDir = Path.Combine(Program.ImagesDir, BatchRslts.Batch.BatchNr.ToString(), (i + 1).ToString());
                             try
                             {
                                 if (File.Exists(Path.Combine(srcDir, fileName)))
@@ -1001,7 +1022,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                                     string destFName = string.IsNullOrEmpty((dataEntryCmpnt as IDataEntryForCamera).TestEndImgName(i, testName))
                                         ? fileName : (dataEntryCmpnt as IDataEntryForCamera).TestEndImgName(i, testName);
                                     File.Copy(Path.Combine(srcDir, fileName), Path.Combine(destDir, destFName), true);
-                                    log.DebugFormat("Save images sourceFile: {0}, destFile: {1} ",Path.Combine(srcDir, fileName), Path.Combine(destDir, destFName));
+                                    log.DebugFormat("Save images sourceFile: {0}, destFile: {1} ", Path.Combine(srcDir, fileName), Path.Combine(destDir, destFName));
                                 }
                             }
                             catch (Exception exc)
@@ -1009,8 +1030,8 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                                 log.ErrorFormat("Failed to copy image {0} to {1}: {2}", fileName, destDir, exc.Message);
                             }
                         }
-					}
-				}
+                    }
+                }
 
                 //...MF...kvapkanie
                 //------------------------------------------------
@@ -1059,14 +1080,14 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
 
                 /// Raw data
                 UpdateTempPressDensAmb(tstRslt);
-                tstRslt.MethodClass  = TbfComponents.FindComponent(test.Method).ClassName;
-                tstRslt.StartTime    = TestStartTime;
-                tstRslt.EndTime      = TestEndTime;
-                tstRslt.FlowSetTime  = flowSetTime;
-                tstRslt.TestTime     = Math.Max(1.0, DateTimeBox.DurationSec(timeStampStart, timeStampEnd));    /// Min. 1s to prevent division by zero
+                tstRslt.MethodClass = TbfComponents.FindComponent(test.Method).ClassName;
+                tstRslt.StartTime = TestStartTime;
+                tstRslt.EndTime = TestEndTime;
+                tstRslt.FlowSetTime = flowSetTime;
+                tstRslt.TestTime = Math.Max(1.0, DateTimeBox.DurationSec(timeStampStart, timeStampEnd));    /// Min. 1s to prevent division by zero
                 tstRslt.PulsesMaster = Convert.ToDouble(cBrd.RefPulses);	                                    /// Pulses of the master flow meter (test total)
                 tstRslt.MassStartRaw = StartMass.Val;
-                tstRslt.MassEndRaw   = EndMass.Val;
+                tstRslt.MassEndRaw = EndMass.Val;
                 tstRslt.TimeBtwnMassMsrmnts = tMass2 - tMass1;
 
                 /// Corrected values
@@ -1077,6 +1098,8 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                 /// Main results
                 tstRslt.VolumeCTV = volumeCTV;							/// [l] 1000.0f is because density is in [kg/m3]
                 tstRslt.Flow = 3.6 * volumeCTV / tstRslt.TestTime;	    /// [m3/h]
+                tstRslt.MassCTV = massCTV;							    /// [kg] 1000.0f is because density is in [kg/m3]
+                tstRslt.MassFlow = 3.6 * massCTV / tstRslt.TestTime;	/// [kg/h]
 
                 if (cBrd is ControlBoard.Uni.UniCB)
                 {
@@ -1085,6 +1108,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                     tstRslt.ConstMasterCorr = outPath.FlowMeter.LtrPerPulseCorrected(tstRslt.Flow, tstRslt.TempDownMean);
                     tstRslt.VolumeMaster = tstRslt.ConstMasterRaw * tstRslt.PulsesMaster;						/// [l] volume from the master flow meter
                     tstRslt.ConstMaster = (tstRslt.VolumeMaster != 0) ? (tstRslt.ConstMasterRaw * tstRslt.VolumeCTV / tstRslt.VolumeMaster) : tstRslt.ConstMasterCorr;
+                    tstRslt.MassConstMaster = (tstRslt.PulsesMaster != 0) ? (tstRslt.MassCTV / tstRslt.PulsesMaster) : tstRslt.ConstMasterCorr;
                 }
                 else
                 {
@@ -1095,11 +1119,12 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                     tstRslt.ConstMaster = 1;
                 }
                 tstRslt.ErrorMaster = Formulas.ErrorFromVolumes(tstRslt.VolumeMaster, tstRslt.VolumeCTV);
+                tstRslt.MassErrorMaster = Formulas.ErrorFromVolumes(tstRslt.VolumeMaster, tstRslt.MassCTV);
 
                 tstRslt.FlowMean = (float)RefFlowStat.Average;
-				tstRslt.FlowStart = (float)RefFlowStat.First;
-				tstRslt.FlowEnd = (float)RefFlowStat.Last;
-				tstRslt.FlowMin = (float)RefFlowStat.Min;
+                tstRslt.FlowStart = (float)RefFlowStat.First;
+                tstRslt.FlowEnd = (float)RefFlowStat.Last;
+                tstRslt.FlowMin = (float)RefFlowStat.Min;
                 tstRslt.FlowMax = (float)RefFlowStat.Max;
 
                 tstRslt.DiverterStart = startSwitchTime.Val;
@@ -1124,7 +1149,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                         for (int isAux = 0; isAux <= 1; isAux++)		/// 0=main, 1=aux
                         {
                             Results.Entities.MeterTestRslt meterRslt = (isAux == 0) ? mainMeterRslt : auxMeterRslt;
-							GenericDevices.IRegReader regReader = sensPath.RegisterReaders[2 * i + isAux];
+                            GenericDevices.IRegReader regReader = sensPath.RegisterReaders[2 * i + isAux];
 
                             if (meterRslt != null && regReader != null)
                             {
@@ -1166,63 +1191,63 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                     ///
                     tstRslt.RefEnergy = Energy.Sum * tstRslt.VolumeCTV / VolumeForEnergy.Sum;   /// [J] = [J] * [l] / [l]
 
-					tstRslt.Custom1  = (float)TempRefHiStat.Average;
-					tstRslt.Custom2  = (float)TempRefHiStat.First;
-					tstRslt.Custom3  = (float)TempRefHiStat.Last;
-					tstRslt.Custom4  = (float)TempRefHiStat.Min;
-					tstRslt.Custom5  = (float)TempRefHiStat.Max;
-					tstRslt.Custom6  = (float)TempRefLoStat.Average;
-					tstRslt.Custom7  = (float)TempRefLoStat.First;
-					tstRslt.Custom8  = (float)TempRefLoStat.Last;
-					tstRslt.Custom9  = (float)TempRefLoStat.Min;
-					tstRslt.Custom10 = (float)TempRefLoStat.Max;																								
+                    tstRslt.Custom1 = (float)TempRefHiStat.Average;
+                    tstRslt.Custom2 = (float)TempRefHiStat.First;
+                    tstRslt.Custom3 = (float)TempRefHiStat.Last;
+                    tstRslt.Custom4 = (float)TempRefHiStat.Min;
+                    tstRslt.Custom5 = (float)TempRefHiStat.Max;
+                    tstRslt.Custom6 = (float)TempRefLoStat.Average;
+                    tstRslt.Custom7 = (float)TempRefLoStat.First;
+                    tstRslt.Custom8 = (float)TempRefLoStat.Last;
+                    tstRslt.Custom9 = (float)TempRefLoStat.Min;
+                    tstRslt.Custom10 = (float)TempRefLoStat.Max;
 
                     for (int i = 0; i < BatchRslts.WMPositionsCount; i++)
                     {
                         if (!test.IsPartCompatible(Utils.PartNr(i + 1, BatchRslts.Batch.Compound))) continue;
 
                         Results.Entities.MeterTestRslt volumeRslt = BatchRslts.GetMeterTestRslt(testName, i, Common.CompoundMeterId.HeatMeterVolume);
-						Results.Entities.MeterTestRslt energyRslt = BatchRslts.GetMeterTestRslt(testName, i, Common.CompoundMeterId.HeatMeterEnergy);
+                        Results.Entities.MeterTestRslt energyRslt = BatchRslts.GetMeterTestRslt(testName, i, Common.CompoundMeterId.HeatMeterEnergy);
 
-						GenericDevices.IRegReader volumeRegReader =
+                        GenericDevices.IRegReader volumeRegReader =
                             (sensPath.RegisterReaders.Length > 2 * i) ? sensPath.RegisterReaders[2 * i] : null;
 
-						GenericDevices.IRegReader energyRegReader =
+                        GenericDevices.IRegReader energyRegReader =
                             (sensPath.RegisterReaders.Length > 2 * i + 1) ? sensPath.RegisterReaders[2 * i + 1] : null;
 
                         if (volumeRslt != null && volumeRegReader != null)
                         {
-							volumeRslt.PulsesPerLiter = volumeRegReader.PulsesPerLtr;
-							volumeRslt.VolumeStart = volumeRegReader.BeginWMState;
-							volumeRslt.VolumeEnd = volumeRegReader.EndWMState;
-							volumeRslt.VolumeMeter = volumeRslt.VolumeEnd - volumeRslt.VolumeStart;
-							volumeRslt.VolumeRef = tstRslt.VolumeCTV;
-							volumeRslt.PulsesMeter = volumeRslt.VolumeMeter;
-							volumeRslt.PulsesMaster = tstRslt.PulsesMaster;		/// <----------------- ???
+                            volumeRslt.PulsesPerLiter = volumeRegReader.PulsesPerLtr;
+                            volumeRslt.VolumeStart = volumeRegReader.BeginWMState;
+                            volumeRslt.VolumeEnd = volumeRegReader.EndWMState;
+                            volumeRslt.VolumeMeter = volumeRslt.VolumeEnd - volumeRslt.VolumeStart;
+                            volumeRslt.VolumeRef = tstRslt.VolumeCTV;
+                            volumeRslt.PulsesMeter = volumeRslt.VolumeMeter;
+                            volumeRslt.PulsesMaster = tstRslt.PulsesMaster;		/// <----------------- ???
 							volumeRslt.TestTime = tstRslt.TestTime;
 
                             volumeRslt.Error = Formulas.ErrorFromVolumes(volumeRslt.VolumeMeter, volumeRslt.VolumeRef);
-							volumeRslt.Passed = !heatMetersTestParams.EvaluateVolume ||
-												((volumeRslt.Error >= test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime) + test.Uncertainty) &&
-												 (volumeRslt.Error <= test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime) - test.Uncertainty) &&
-        										 (tstRslt.ErrorFlags == 0));
-							volumeRslt.TestDone = true;
+                            volumeRslt.Passed = !heatMetersTestParams.EvaluateVolume ||
+                                                ((volumeRslt.Error >= test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime) + test.Uncertainty) &&
+                                                 (volumeRslt.Error <= test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime) - test.Uncertainty) &&
+                                                 (tstRslt.ErrorFlags == 0));
+                            volumeRslt.TestDone = true;
                             tstRslt.TestDone = true;
                         }
 
                         if (energyRslt != null && energyRegReader != null && dataEntryCmpnt is GenericDevices.IHasHeatMtrStatesForm)
-						{
-							volumeRslt.PulsesPerLiter = energyRegReader.PulsesPerLtr;
-							energyRslt.VolumeStart = (dataEntryCmpnt as GenericDevices.IHasHeatMtrStatesForm).EnergyStartState(i);
-							energyRslt.VolumeEnd = (dataEntryCmpnt as GenericDevices.IHasHeatMtrStatesForm).EnergyEndState(i);
-							energyRslt.VolumeMeter = energyRslt.VolumeEnd - energyRslt.VolumeStart;
-							energyRslt.VolumeRef = tstRslt.RefEnergy;
-							energyRslt.PulsesMeter = energyRslt.VolumeMeter;
+                        {
+                            volumeRslt.PulsesPerLiter = energyRegReader.PulsesPerLtr;
+                            energyRslt.VolumeStart = (dataEntryCmpnt as GenericDevices.IHasHeatMtrStatesForm).EnergyStartState(i);
+                            energyRslt.VolumeEnd = (dataEntryCmpnt as GenericDevices.IHasHeatMtrStatesForm).EnergyEndState(i);
+                            energyRslt.VolumeMeter = energyRslt.VolumeEnd - energyRslt.VolumeStart;
+                            energyRslt.VolumeRef = tstRslt.RefEnergy;
+                            energyRslt.PulsesMeter = energyRslt.VolumeMeter;
                             energyRslt.PulsesMaster = tstRslt.PulsesMaster;		/// <----------------- ???
 
                             energyRslt.Error = Formulas.ErrorFromVolumes(energyRslt.VolumeMeter, energyRslt.VolumeRef);
-							energyRslt.Passed = (energyRslt.Error >= heatMetersTestParams.ErrorLimitLo)
-											 && (energyRslt.Error <= heatMetersTestParams.ErrorLimitHi)
+                            energyRslt.Passed = (energyRslt.Error >= heatMetersTestParams.ErrorLimitLo)
+                                             && (energyRslt.Error <= heatMetersTestParams.ErrorLimitHi)
                                              && (tstRslt.ErrorFlags == 0);
                             energyRslt.TestDone = true;
                             tstRslt.TestDone = true;
@@ -1244,18 +1269,75 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                         if (meterRslt != null && regReader != null)
                         {
                             meterRslt.RegReaderType = (int)regReader.RegisterReaderType;
-                            meterRslt.PulsesPerLiter = regReader.PulsesPerLtr;
+
+
+                            ComponentProcedure procParamsEntity = test.Procedure.GetProcedureParamsEntity(regReader.Name);
+
+                            try
+                            {
+                                if (regReader.RegisterReaderType == RegisterReaderType.Pulses || regReader.RegisterReaderType == RegisterReaderType.Manual)
+                                {
+                                    XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(RRProcParams) })[0];
+                                    RRProcParams tmp = Serializer.Deserialize(new StringReader(procParamsEntity.Parameters.ToString())) as RRProcParams;
+                                    regReader.PulsesPerLtr = tmp.PulsesPerLtr;
+                                    regReader.QuantityUnits = tmp.Units;
+                                }
+                                else
+                                {
+                                    //MessageBox.Show("Cannot create or initialize a printer", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
+                                }
+                            }
+                            catch (Exception ex)
+                            {
+                                /*log.DebugFormat(
+                                    "Error during Procedure parameters deserialization. CmpntName='{0}', Procedure='{1}', Parameters='{2}', Exception: {3}",
+                                    dbEntity?.CmpntName,
+                                    dbEntity?.Procedure,
+                                    dbEntity?.Parameters,
+                                    ex
+                                );*/
+                            }
+
+                            meterRslt.PulsesPerLiter = regReader.PulsesPerLtr;//...MF 11.12.2025 toto chybalo, v .csv bol stlpec naplneny nulami
+                            meterRslt.QuantityUnits = regReader.QuantityUnits;
                             meterRslt.VolumeStart = regReader.BeginWMState;
                             meterRslt.VolumeEnd = regReader.EndWMState;
                             meterRslt.VolumeMeter = Math.Abs(meterRslt.VolumeEnd - meterRslt.VolumeStart);
-                            meterRslt.VolumeRef = tstRslt.VolumeCTV;      /// liter
+                            meterRslt.MassMeter = Math.Abs(meterRslt.VolumeEnd - meterRslt.VolumeStart);
+                            meterRslt.VolumeRef = tstRslt.VolumeCTV;        /// liter
+                            meterRslt.MassRef = tstRslt.MassCTV;            /// kg
                             meterRslt.PulsesMeter = meterRslt.VolumeMeter;
                             meterRslt.PulsesMaster = tstRslt.PulsesMaster;
                             meterRslt.TestTime = tstRslt.TestTime;
-                            meterRslt.Error = Formulas.ErrorFromVolumes(meterRslt.VolumeMeter, meterRslt.VolumeRef);
-                            meterRslt.Passed = (meterRslt.Error >= test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime) + test.Uncertainty)
+
+                            //meterRslt.Error = Formulas.ErrorFromVolumes(meterRslt.VolumeMeter, meterRslt.VolumeRef);
+                            double Error = 0;
+                            if (meterRslt.GetQuantityFromUnits() == "Mass")
+                                Error = Formulas.ErrorFromVolumes(meterRslt.MassMeter, meterRslt.MassRef);
+                            else
+                                Error = Formulas.ErrorFromVolumes(meterRslt.VolumeMeter, meterRslt.VolumeRef);
+
+                            meterRslt.Error = Error;
+
+                            /*meterRslt.Passed = (meterRslt.Error >= test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime) + test.Uncertainty)
                                             && (meterRslt.Error <= test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime) - test.Uncertainty)
-                                            && (tstRslt.ErrorFlags == 0);
+                                            && (tstRslt.ErrorFlags == 0);*/
+                            var ErrLimLo_Volume = test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime);
+                            var ErrLimHi_Volume = test.GetErrLimHi(tstRslt.VolumeCTV, tstRslt.TestTime);
+                            var ErrLimLo_Mass = test.GetErrLimLo(tstRslt.MassCTV, tstRslt.TestTime);
+                            var ErrLimHi_Mass = test.GetErrLimHi(tstRslt.MassCTV, tstRslt.TestTime);
+
+                            bool Passed;
+                            if (meterRslt.GetQuantityFromUnits() == "Mass")
+                                Passed = (meterRslt.Error >= ErrLimLo_Volume + test.Uncertainty) &&
+                                (meterRslt.Error <= ErrLimHi_Volume - test.Uncertainty) &&
+                                (tstRslt.ErrorFlags == 0);
+                            else
+                                Passed = (meterRslt.Error >= ErrLimLo_Mass + test.Uncertainty) &&
+                                (meterRslt.Error <= ErrLimHi_Mass - test.Uncertainty) &&
+                                (tstRslt.ErrorFlags == 0);
+
+                            meterRslt.Passed = Passed;
                             meterRslt.TestDone = true;
                             tstRslt.TestDone = true;
                             if (regReader is ICommonRegReader regReaderCommon)
@@ -1265,7 +1347,7 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
                             {
                                 meterRslt.WaterMeter.SerialNr = regReaderCommon.SerialNr;
                             }
-                            
+
                         }
                     }
                 }
@@ -1308,9 +1390,9 @@ namespace TBF.Rig.TestMethods.StandingStartMassCollection
 
             if (stopCycle) retVal = Event.ErrorFlagsStop;
 
-        stopTest:
+            stopTest:
 
-			StopRecordingStatistics();
+            StopRecordingStatistics();
 
             ///
             ///  Quit this sequence