//-------------------------------------------------------------------------------------------------//
        protected void Application_Start(object sender, EventArgs e)
        {
            const string STRLOG_MethodName = "Application_Start";

            //
            // Set the filepath for the log files
            //
            string rootFilePath = HostingEnvironment.ApplicationPhysicalPath;
            string logFilesPath = Utilities.GetAppSetting(Consts.STRCFG_LogFilesPath);
            Logfile.SetFilePath(Path.Combine(rootFilePath, logFilesPath));

            Logfile.Write("");
            Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);

            //
            // Create the experiment manager
            //
            allowedServiceBrokers = new AllowedServiceBrokersDB();
            configuration = new Configuration(rootFilePath);
            experimentManager = new ExperimentManager(allowedServiceBrokers, configuration);
            experimentManager.Create();

            //
            // Now start the experiment manager
            //
            experimentManager.Start();

            Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName);
        }
 //-------------------------------------------------------------------------------------------------//
 public ExperimentResult(Configuration configuration)
     : base(configuration)
 {
     try
     {
         //
         // Check that all required XML nodes exist
         //
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_formatName, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_serverUrl, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_timeofday, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_dayofweek, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_day, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_month, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_year, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_hours, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_minutes, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_seconds, true);
     }
     catch (Exception ex)
     {
         // Log the message and throw the exception back to the caller
         Logfile.WriteError(ex.Message);
         throw;
     }
 }
        //-------------------------------------------------------------------------------------------------//

        protected void Application_Start(object sender, EventArgs e)
        {
            const string STRLOG_MethodName = "Application_Start";

            //
            // Set the filepath for the log files
            //
            string rootFilePath = HostingEnvironment.ApplicationPhysicalPath;
            string logFilesPath = Utilities.GetAppSetting(Consts.STRCFG_LogFilesPath);

            Logfile.SetFilePath(Path.Combine(rootFilePath, logFilesPath));

            Logfile.Write("");
            Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);

            //
            // Create the experiment manager
            //
            allowedServiceBrokers = new AllowedServiceBrokersDB();
            configuration         = new Library.LabServer.Configuration(rootFilePath);
            experimentManager     = new ExperimentManager(allowedServiceBrokers, configuration);
            experimentManager.Create();

            //
            // Now start the experiment manager
            //
            experimentManager.Start();

            Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName);
        }
 //-------------------------------------------------------------------------------------------------//
 public ExperimentResult(Configuration configuration)
     : base(configuration)
 {
     try
     {
         //
         // Check that all required XML nodes exist
         //
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_speedMin, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_speedMax, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_speedStep, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_fieldMin, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_fieldMax, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_fieldStep, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_loadMin, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_loadMax, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_loadStep, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_speedVector, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_fieldVector, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_voltageVector, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_loadVector, true);
     }
     catch (Exception ex)
     {
         // Log the message and throw the exception back to the caller
         Logfile.WriteError(ex.Message);
         throw;
     }
 }
        //-------------------------------------------------------------------------------------------------//
        public Specification(Configuration configuration, EquipmentService equipmentServiceProxy)
            : base(configuration, equipmentServiceProxy)
        {
            const string STRLOG_MethodName = "Specification";

            Logfile.WriteCalled(null, STRLOG_MethodName);

            //
            // Save these for use by the Parse() method
            //
            this.configuration = configuration;

            //
            // Check that the specification template is valid. This is used by the LabClient to submit
            // the experiment specification to the LabServer for execution.
            //
            try
            {
                //
                // Check that all required XML nodes exist
                //
                //
                // Nothing to do here
                //
            }
            catch (Exception ex)
            {
                Logfile.WriteError(ex.Message);
                throw;
            }

            Logfile.WriteCompleted(null, STRLOG_MethodName);
        }
        //-------------------------------------------------------------------------------------------------//
        public ExperimentResult(int experimentId, string sbName, DateTime dateTime, int unitId, Configuration configuration,
            Specification specification, ResultInfo resultInfo)
            : base(experimentId, sbName, dateTime, specification.SetupId, unitId, configuration)
        {
            const string STRLOG_MethodName = "ExperimentResult";

            Logfile.WriteCalled(null, STRLOG_MethodName);

            try
            {
                //
                // Add the specification information
                //
                //
                // YOUR CODE HERE
                //

                //
                // Add the result information
                //
                if (resultInfo.statusCode == StatusCodes.Completed)
                {
                    //
                    // YOUR CODE HERE
                    //
                }
            }
            catch (Exception ex)
            {
                Logfile.WriteError(ex.Message);
                throw;
            }

            Logfile.WriteCompleted(null, STRLOG_MethodName);
        }
        //-------------------------------------------------------------------------------------------------//
        public Validation(Configuration configuration)
            : base(configuration)
        {
            const string STRLOG_MethodName = "Validation";

            Logfile.WriteCalled(null, STRLOG_MethodName);

            //
            // Get information from the validation XML node
            //
            try
            {
                //
                // Get distance range information from the validation node
                //
                XmlNode xmlNode = XmlUtilities.GetXmlNode(this.xmlNodeValidation, Consts.STRXML_vdnDistance);
                this.distance = new VdnMinMax();
                this.distance.min = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_minimum);
                this.distance.max = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_maximum);

                //
                // Get duration range information from the validation node
                //
                xmlNode = XmlUtilities.GetXmlNode(this.xmlNodeValidation, Consts.STRXML_vdnDuration);
                this.duration = new VdnMinMax();
                this.duration.min = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_minimum);
                this.duration.max = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_maximum);

                //
                // Get distance range information from the validation node
                //
                xmlNode = XmlUtilities.GetXmlNode(this.xmlNodeValidation, Consts.STRXML_vdnRepeat);
                this.repeat = new VdnMinMax();
                this.repeat.min = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_minimum);
                this.repeat.max = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_maximum);

                //
                // Get distance range information from the validation node
                //
                xmlNode = XmlUtilities.GetXmlNode(this.xmlNodeValidation, Consts.STRXML_vdnTotaltime);
                this.totalTime = new VdnMinMax();
                this.totalTime.min = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_minimum);
                this.totalTime.max = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_maximum);

            }
            catch (Exception ex)
            {
                Logfile.WriteError(ex.Message);
                throw;
            }

            Logfile.WriteCompleted(null, STRLOG_MethodName);
        }
        //-------------------------------------------------------------------------------------------------//
        public Validation(Configuration configuration)
            : base(configuration)
        {
            const string STRLOG_MethodName = "Validation";

            Logfile.WriteCalled(null, STRLOG_MethodName);

            //
            // Get information from the validation XML node
            //
            try
            {
                //
                // Get speed range information from the lab configuration node
                //
                XmlNode xmlNode = XmlUtilities.GetXmlNode(this.xmlNodeValidation, Consts.STRXML_vdnSpeed);
                this.speed = new VdnMinMaxStep();
                this.speed.min = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_minimum);
                this.speed.max = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_maximum);
                this.speed.stepMin = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_stepMin);
                this.speed.stepMax = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_stepMax);

                //
                // Get field range information from the lab configuration node
                //
                xmlNode = XmlUtilities.GetXmlNode(this.xmlNodeValidation, Consts.STRXML_vdnField);
                this.field = new VdnMinMaxStep();
                this.field.min = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_minimum);
                this.field.max = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_maximum);
                this.field.stepMin = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_stepMin);
                this.field.stepMax = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_stepMax);

                //
                // Get load range information from the lab configuration node
                //
                xmlNode = XmlUtilities.GetXmlNode(this.xmlNodeValidation, Consts.STRXML_vdnLoad);
                this.load = new VdnMinMaxStep();
                this.load.min = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_minimum);
                this.load.max = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_maximum);
                this.load.stepMin = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_stepMin);
                this.load.stepMax = XmlUtilities.GetIntValue(xmlNode, Consts.STRXML_stepMax);
            }
            catch (Exception ex)
            {
                Logfile.WriteError(ex.Message);
                throw;
            }

            Logfile.WriteCompleted(null, STRLOG_MethodName);
        }
        //-------------------------------------------------------------------------------------------------//
        public Specification(Configuration configuration, EquipmentService equipmentServiceProxy)
            : base(configuration, equipmentServiceProxy)
        {
            const string STRLOG_MethodName = "Specification";

            Logfile.WriteCalled(null, STRLOG_MethodName);

            //
            // Save these for use by the Parse() method
            //
            this.configuration = configuration;

            //
            // Check that the specification template is valid. This is used by the LabClient to submit
            // the experiment specification to the LabServer for execution.
            //
            try
            {
                //
                // Check that all required XML nodes exist
                //
                XmlUtilities.GetXmlValue(this.xmlNodeSpecification, Consts.STRXML_speedMin, true);
                XmlUtilities.GetXmlValue(this.xmlNodeSpecification, Consts.STRXML_speedMax, true);
                XmlUtilities.GetXmlValue(this.xmlNodeSpecification, Consts.STRXML_speedStep, true);
                XmlUtilities.GetXmlValue(this.xmlNodeSpecification, Consts.STRXML_fieldMin, true);
                XmlUtilities.GetXmlValue(this.xmlNodeSpecification, Consts.STRXML_fieldMax, true);
                XmlUtilities.GetXmlValue(this.xmlNodeSpecification, Consts.STRXML_fieldStep, true);
                XmlUtilities.GetXmlValue(this.xmlNodeSpecification, Consts.STRXML_loadMin, true);
                XmlUtilities.GetXmlValue(this.xmlNodeSpecification, Consts.STRXML_loadMax, true);
                XmlUtilities.GetXmlValue(this.xmlNodeSpecification, Consts.STRXML_loadStep, true);

                //
                // Create an instance fo the Validation class
                //
                this.validation = new Validation(configuration);
            }
            catch (Exception ex)
            {
                Logfile.WriteError(ex.Message);
                throw;
            }

            Logfile.WriteCompleted(null, STRLOG_MethodName);
        }
 //-------------------------------------------------------------------------------------------------//
 public ExperimentResult(Configuration configuration)
     : base(configuration)
 {
     try
     {
         //
         // Check that all required XML nodes exist
         //
         //
         // Nothing to do here
         //
     }
     catch (Exception ex)
     {
         // Log the message and throw the exception back to the caller
         Logfile.WriteError(ex.Message);
         throw;
     }
 }
        //-------------------------------------------------------------------------------------------------//
        public ExperimentResult(int experimentId, string sbName, DateTime dateTime, int unitId, Configuration configuration,
            Specification specification, ResultInfo resultInfo)
            : base(experimentId, sbName, dateTime, specification.SetupId, unitId, configuration)
        {
            const string STRLOG_MethodName = "ExperimentResult";

            Logfile.WriteCalled(null, STRLOG_MethodName);

            try
            {
                //
                // Add the specification information
                //
                XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_formatName, specification.FormatName, false);
                if (specification.SetupId.Equals(Consts.STRXML_SetupId_NTPServer))
                {
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_serverUrl, specification.ServerUrl, false);
                }

                //
                // Add the result information
                //
                if (resultInfo.statusCode == StatusCodes.Completed)
                {
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_timeofday, resultInfo.timeofday, false);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_dayofweek, resultInfo.dateTime.DayOfWeek.ToString(), false);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_day, resultInfo.dateTime.Day);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_month, resultInfo.dateTime.Month);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_year, resultInfo.dateTime.Year);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_hours, resultInfo.dateTime.Hour);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_minutes, resultInfo.dateTime.Minute);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_seconds, resultInfo.dateTime.Second);
                }
            }
            catch (Exception ex)
            {
                Logfile.WriteError(ex.Message);
                throw;
            }

            Logfile.WriteCompleted(null, STRLOG_MethodName);
        }
 //-------------------------------------------------------------------------------------------------//
 public ExperimentResult(Configuration configuration)
     : base(configuration)
 {
     try
     {
         //
         // Check that all required XML nodes exist
         //
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_sourceName, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_absorberName, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_distance, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_duration, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_repeat, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_dataType, true);
         XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_dataVector, true);
     }
     catch (Exception ex)
     {
         // Log the message and throw the exception back to the caller
         Logfile.WriteError(ex.Message);
         throw;
     }
 }
        //-------------------------------------------------------------------------------------------------//
        public Validation(Configuration configuration)
            : base(configuration)
        {
            const string STRLOG_MethodName = "Validation";

            Logfile.WriteCalled(null, STRLOG_MethodName);

            //
            // Get information from the validation XML node
            //
            try
            {
                //
                // YOUR CODE HERE
                //
            }
            catch (Exception ex)
            {
                Logfile.WriteError(ex.Message);
                throw;
            }

            Logfile.WriteCompleted(null, STRLOG_MethodName);
        }
        //-------------------------------------------------------------------------------------------------//
        public ExperimentResult(int experimentId, string sbName, DateTime dateTime, int unitId, Configuration configuration,
            Specification specification, ResultInfo resultInfo)
            : base(experimentId, sbName, dateTime, specification.SetupId, unitId, configuration)
        {
            const string STRLOG_MethodName = "ExperimentResult";

            Logfile.WriteCalled(null, STRLOG_MethodName);

            try
            {
                //
                // Add the specification information
                //
                //
                // Nothing to do here
                //

                //
                // Add the result information
                //
                if (resultInfo.statusCode == StatusCodes.Completed)
                {
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_voltage, resultInfo.voltage.ToString("F02"), false);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_current, resultInfo.current.ToString("F03"), false);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_powerFactor, resultInfo.powerFactor.ToString("F04"), false);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_speed, resultInfo.speed.ToString(), false);
                }
            }
            catch (Exception ex)
            {
                Logfile.WriteError(ex.Message);
                throw;
            }

            Logfile.WriteCompleted(null, STRLOG_MethodName);
        }
 //-------------------------------------------------------------------------------------------------//
 public ExperimentManager(AllowedServiceBrokersDB allowedServiceBrokers, Configuration configuration)
     : this(allowedServiceBrokers, configuration, 0)
 {
 }
        //-------------------------------------------------------------------------------------------------//
        public ExperimentResult(int experimentId, string sbName, DateTime dateTime, int unitId, Configuration configuration,
            Specification specification, ResultInfo resultInfo)
            : base(experimentId, sbName, dateTime, specification.SetupId, unitId, configuration)
        {
            const string STRLOG_MethodName = "ExperimentResult";

            Logfile.WriteCalled(null, STRLOG_MethodName);

            try
            {
                //
                // Add the specification information
                //
                //
                // Nothing to do here
                //

                //
                // Add the result information
                //
                if (resultInfo.statusCode == StatusCodes.Completed)
                {
                    string[] measurements = null;

                    //
                    // Load XML measurements string
                    //
                    XmlDocument xmlDocument = XmlUtilities.GetXmlDocument(resultInfo.xmlMeasurements);
                    XmlNode xmlNodeRoot = XmlUtilities.GetXmlRootNode(xmlDocument, Consts.STRXML_measurements);

                    if (specification.SetupId.Equals(Consts.STRXML_SetupId_OpenCircuitVaryField) == true)
                    {
                        measurements = new string[] {
                            Consts.STRXML_fieldCurrent,
                            Consts.STRXML_speed,
                            Consts.STRXML_voltage,
                        };
                    }
                    else if (specification.SetupId.Equals(Consts.STRXML_SetupId_OpenCircuitVarySpeed) == true)
                    {
                        measurements = new string[] {
                            Consts.STRXML_speed,
                            Consts.STRXML_fieldCurrent,
                            Consts.STRXML_voltage,
                        };
                    }
                    else if (specification.SetupId.Equals(Consts.STRXML_SetupId_ShortCircuitVaryField) == true)
                    {
                        measurements = new string[] {
                            Consts.STRXML_fieldCurrent,
                            Consts.STRXML_speed,
                            Consts.STRXML_statorCurrent,
                        };
                    }
                    else if (specification.SetupId.Equals(Consts.STRXML_SetupId_PreSynchronisation) == true)
                    {
                        measurements = new string[] {
                            Consts.STRXML_fieldCurrent,
                            Consts.STRXML_speedSetpoint,
                            Consts.STRXML_mainsVoltage,
                            Consts.STRXML_mainsFrequency,
                            Consts.STRXML_syncVoltage,
                            Consts.STRXML_syncFrequency,
                            Consts.STRXML_syncMainsPhase,
                            Consts.STRXML_synchronism,
                        };
                    }
                    else if (specification.SetupId.Equals(Consts.STRXML_SetupId_Synchronisation) == true)
                    {
                        measurements = new string[] {
                            Consts.STRXML_torqueSetpoint,
                            Consts.STRXML_fieldCurrent,
                            Consts.STRXML_syncVoltage,
                            Consts.STRXML_syncFrequency,
                            Consts.STRXML_powerFactor,
                            Consts.STRXML_realPower,
                            Consts.STRXML_reactivePower,
                            Consts.STRXML_phaseCurrent,
                        };
                    }

                    if (measurements != null)
                    {
                        for (int i = 0; i < measurements.Length; i++)
                        {
                            XmlNode xmlNode = XmlUtilities.GetXmlNode(xmlNodeRoot, measurements[i]);
                            XmlDocumentFragment xmlFragment = this.xmlNodeExperimentResult.OwnerDocument.CreateDocumentFragment();
                            xmlFragment.InnerXml = xmlNode.OuterXml;
                            this.xmlNodeExperimentResult.AppendChild(xmlFragment);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logfile.WriteError(ex.Message);
                throw;
            }

            Logfile.WriteCompleted(null, STRLOG_MethodName);
        }
 //-------------------------------------------------------------------------------------------------//
 public ExperimentManager(AllowedServiceBrokersDB allowedServiceBrokers, Configuration configuration, int farmSize)
     : base(allowedServiceBrokers, configuration, farmSize)
 {
 }
        //-------------------------------------------------------------------------------------------------//
        public ExperimentResult(int experimentId, string sbName, DateTime dateTime, int unitId, Configuration configuration,
            Specification specification, ResultInfo resultInfo)
            : base(experimentId, sbName, dateTime, specification.SetupId, unitId, configuration)
        {
            const string STRLOG_MethodName = "ExperimentResult";

            Logfile.WriteCalled(null, STRLOG_MethodName);

            try
            {
                //
                // Add the specification information
                //
                if (specification.SetupId.Equals(Consts.STRXML_SetupId_VoltageVsSpeed))
                {
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_speedMin, specification.Speed.min);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_speedMax, specification.Speed.max);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_speedStep, specification.Speed.step);
                }
                else if (specification.SetupId.Equals(Consts.STRXML_SetupId_VoltageVsField))
                {
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_fieldMin, specification.Field.min);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_fieldMax, specification.Field.max);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_fieldStep, specification.Field.step);
                }
                else if (specification.SetupId.Equals(Consts.STRXML_SetupId_VoltageVsLoad))
                {
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_loadMin, specification.Load.min);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_loadMax, specification.Load.max);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_loadStep, specification.Load.step);
                }
                else if (specification.SetupId.Equals(Consts.STRXML_SetupId_SpeedVsVoltage))
                {
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_speedMin, specification.Speed.min);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_speedMax, specification.Speed.max);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_speedStep, specification.Speed.step);
                }
                else if (specification.SetupId.Equals(Consts.STRXML_SetupId_SpeedVsField))
                {
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_fieldMin, specification.Field.min);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_fieldMax, specification.Field.max);
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_fieldStep, specification.Field.step);
                }

                //
                // Add the result information
                //
                if (resultInfo.statusCode == StatusCodes.Completed)
                {
                    if (specification.SetupId.Equals(Consts.STRXML_SetupId_VoltageVsSpeed))
                    {
                        XmlUtilities.SetXmlValues(this.xmlNodeExperimentResult, Consts.STRXML_speedVector, resultInfo.speedVector, Consts.CHR_Splitter, false);
                        XmlUtilities.SetXmlValues(this.xmlNodeExperimentResult, Consts.STRXML_voltageVector, resultInfo.voltageVector, Consts.CHR_Splitter, false);
                    }
                    else if (specification.SetupId.Equals(Consts.STRXML_SetupId_VoltageVsField))
                    {
                        XmlUtilities.SetXmlValues(this.xmlNodeExperimentResult, Consts.STRXML_fieldVector, resultInfo.fieldVector, "F02", Consts.CHR_Splitter, false);
                        XmlUtilities.SetXmlValues(this.xmlNodeExperimentResult, Consts.STRXML_voltageVector, resultInfo.voltageVector, Consts.CHR_Splitter, false);
                    }
                    else if (specification.SetupId.Equals(Consts.STRXML_SetupId_VoltageVsLoad))
                    {
                        XmlUtilities.SetXmlValues(this.xmlNodeExperimentResult, Consts.STRXML_loadVector, resultInfo.loadVector, Consts.CHR_Splitter, false);
                        XmlUtilities.SetXmlValues(this.xmlNodeExperimentResult, Consts.STRXML_voltageVector, resultInfo.voltageVector, Consts.CHR_Splitter, false);
                        XmlUtilities.SetXmlValues(this.xmlNodeExperimentResult, Consts.STRXML_speedVector, resultInfo.speedVector, Consts.CHR_Splitter, false);
                    }
                    else if (specification.SetupId.Equals(Consts.STRXML_SetupId_SpeedVsVoltage))
                    {
                        XmlUtilities.SetXmlValues(this.xmlNodeExperimentResult, Consts.STRXML_speedVector, resultInfo.speedVector, Consts.CHR_Splitter, false);
                        XmlUtilities.SetXmlValues(this.xmlNodeExperimentResult, Consts.STRXML_voltageVector, resultInfo.voltageVector, Consts.CHR_Splitter, false);
                    }
                    else if (specification.SetupId.Equals(Consts.STRXML_SetupId_SpeedVsField))
                    {
                        XmlUtilities.SetXmlValues(this.xmlNodeExperimentResult, Consts.STRXML_fieldVector, resultInfo.fieldVector, "F02", Consts.CHR_Splitter, false);
                        XmlUtilities.SetXmlValues(this.xmlNodeExperimentResult, Consts.STRXML_speedVector, resultInfo.speedVector, Consts.CHR_Splitter, false);
                        XmlUtilities.SetXmlValues(this.xmlNodeExperimentResult, Consts.STRXML_voltageVector, resultInfo.voltageVector, Consts.CHR_Splitter, false);
                    }
                }
            }
            catch (Exception ex)
            {
                Logfile.WriteError(ex.Message);
                throw;
            }

            Logfile.WriteCompleted(null, STRLOG_MethodName);
        }
        //-------------------------------------------------------------------------------------------------//
        public ExperimentResult(int experimentId, string sbName, DateTime dateTime, int unitId, Configuration configuration,
            Specification specification, ResultInfo resultInfo)
            : base(experimentId, sbName, dateTime, specification.SetupId, unitId, configuration)
        {
            const string STRLOG_MethodName = "ExperimentResult";

            Logfile.WriteCalled(null, STRLOG_MethodName);

            try
            {
                //
                // Add the specification information
                //
                XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_sourceName, specification.SourceName, false);
                XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_duration, specification.Duration);
                XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_repeat, specification.Repeat);
                if (specification.SetupId.Equals(Consts.STRXML_SetupId_RadioactivityVsTime) ||
                    specification.SetupId.Equals(Consts.STRXML_SetupId_SimActivityVsTime) ||
                    specification.SetupId.Equals(Consts.STRXML_SetupId_SimActivityVsTimeNoDelay))
                {
                    Specification.Absorber absorber = specification.AbsorberList[0];
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_absorberName, absorber.name, false);

                    int distance = specification.DistanceList[0];
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_distance, distance.ToString(), false);
                }
                else if (specification.SetupId.Equals(Consts.STRXML_SetupId_RadioactivityVsDistance) ||
                    specification.SetupId.Equals(Consts.STRXML_SetupId_SimActivityVsDistance) ||
                    specification.SetupId.Equals(Consts.STRXML_SetupId_SimActivityVsDistanceNoDelay))
                {
                    Specification.Absorber absorber = specification.AbsorberList[0];
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_absorberName, absorber.name, false);

                    //
                    // Create a CSV string of distances
                    //
                    string csvDistances = string.Empty;
                    for (int i = 0; i < specification.DistanceList.Length; i++)
                    {
                        if (i > 0)
                        {
                            csvDistances += Consts.CHR_CsvSplitter;
                        }
                        csvDistances += specification.DistanceList[i].ToString();
                    }
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_distance, csvDistances, false);
                }
                else if (specification.SetupId.Equals(Consts.STRXML_SetupId_RadioactivityVsAbsorber))
                {
                    //
                    // Create a CSV string of absorbers
                    //
                    string csvAbsorbers = string.Empty;
                    for (int i = 0; i < specification.AbsorberList.Length; i++)
                    {
                        if (i > 0)
                        {
                            csvAbsorbers += Consts.CHR_CsvSplitter;
                        }
                        csvAbsorbers += specification.AbsorberList[i].name;
                    }
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_absorberName, csvAbsorbers, false);

                    int distance = specification.DistanceList[0];
                    XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_distance, distance.ToString(), false);
                }

                //
                // Add the result information
                //
                if (resultInfo.statusCode == StatusCodes.Completed)
                {
                    if (specification.SetupId.Equals(Consts.STRXML_SetupId_RadioactivityVsTime) ||
                        specification.SetupId.Equals(Consts.STRXML_SetupId_RadioactivityVsDistance) ||
                        specification.SetupId.Equals(Consts.STRXML_SetupId_RadioactivityVsAbsorber) ||
                        specification.SetupId.Equals(Consts.STRXML_SetupId_SimActivityVsTime) ||
                        specification.SetupId.Equals(Consts.STRXML_SetupId_SimActivityVsDistance) ||
                        specification.SetupId.Equals(Consts.STRXML_SetupId_SimActivityVsTimeNoDelay) ||
                        specification.SetupId.Equals(Consts.STRXML_SetupId_SimActivityVsDistanceNoDelay))
                    {
                        XmlUtilities.SetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_dataType, resultInfo.dataType.ToString(), false);
                        XmlNode xmlNode = XmlUtilities.GetXmlNode(this.xmlNodeExperimentResult, Consts.STRXML_dataVector);
                        XmlNode xmlNodeCopy = null;
                        XmlNode xmlNodeTemp = null;
                        for (int i = 0; i < resultInfo.dataVectors.GetLength(0); i++)
                        {
                            if (i == 0)
                            {
                                // Keep a copy of the node for more dataVectors
                                xmlNodeCopy = xmlNode.Clone();
                                xmlNodeTemp = xmlNode;
                            }
                            else
                            {
                                // Get a copy of the nodeCopy to add another dataVector
                                xmlNodeTemp = xmlNodeCopy.Clone();
                            }

                            //
                            // Create CSV string from data vector
                            //
                            string csvString = string.Empty;
                            for (int j = 0; j < resultInfo.dataVectors.GetLength(1); j++)
                            {
                                if (j > 0)
                                {
                                    csvString += Consts.CHR_CsvSplitter;
                                }
                                csvString += resultInfo.dataVectors[i, j].ToString();
                            }
                            xmlNodeTemp.InnerXml = csvString;

                            if (i > 0)
                            {
                                // Append xml fragment to experiment result node
                                this.xmlNodeExperimentResult.AppendChild(xmlNodeTemp);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logfile.WriteError(ex.Message);
                throw;
            }

            Logfile.WriteCompleted(null, STRLOG_MethodName);
        }
 //-------------------------------------------------------------------------------------------------//
 public ExperimentEngine(int unitId, AppData appData)
     : base(unitId, appData)
 {
     this.configuration = (Configuration)appData.labConfiguration;
 }