//******************************************************************************************************//  BestValueSelector.cs - Gbtc////  Copyright © 2017, Grid Protection Alliance.  All Rights Reserved.////  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See//  the NOTICE file distributed with this work for additional information regarding copyright ownership.//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may not use this//  file except in compliance with the License. You may obtain a copy of the License at:////      http://opensource.org/licenses/MIT////  Unless agreed to in writing, the subject software distributed under the License is distributed on an//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the//  License for the specific language governing permissions and limitations.////  Code Modification History://  ----------------------------------------------------------------------------------------------------//  11/06/2017 - Stephen C. Wills//       Generated original version of source code.////****************************************************************************************************** using System;using System.Collections.Generic;using System.ComponentModel;using System.Linq;using System.Text;using GSF;using GSF.TimeSeries;using GSF.TimeSeries.Adapters; namespace DataQualityMonitoring{    /// <summary>    /// Produces a new signal by selecting the best values    /// from a collection of concentrated data points.    /// </summary>    [Description("Best Value: Produces a new signal by selecting only the best values from a collection of input signals.")]    public class BestValueSelector : ActionAdapterBase    {        #region [ Members ]         // Constants         /// <summary>        /// Defines the default value for the <see cref="PublishBadValues"/> property.        /// </summary>        public const bool DefaultPublishBadValues = false;         /// <summary>        /// Defines the default value for the <see cref="DefaultBadFlags"/> property.        /// </summary>        public const MeasurementStateFlags DefaultBadFlags =            MeasurementStateFlags.AlarmHigh |            MeasurementStateFlags.AlarmLow |            MeasurementStateFlags.BadData |            MeasurementStateFlags.CalculationError |            MeasurementStateFlags.ComparisonAlarm |            MeasurementStateFlags.FlatlineAlarm |            MeasurementStateFlags.MeasurementError |            MeasurementStateFlags.OverRangeError |            MeasurementStateFlags.ReceivedAsBad |            MeasurementStateFlags.SuspectData |            MeasurementStateFlags.UnderRangeError;         /// <summary>        /// Defines the default value for the <see cref="HandleZeroAsBad"/> property.        /// </summary>        public const bool DefaultHandleZeroAsBad = false;         /// <summary>        /// Defines the default value for the <see cref="HandleNaNAsBad"/> property.        /// </summary>        public const bool DefaultHandleNaNAsBad = true;         /// <summary>        /// Defines the default value for the <see cref="SupportsTemporalProcessing"/> property.        /// </summary>        public const bool DefaultSupportsTemporalProcessing = false;         // Fields        private bool m_publishBadValues;        private MeasurementStateFlags m_badFlags;        private bool m_handleZeroAsBad;        private bool m_handleNaNAsBad;        private bool m_supportsTemporalProcessing;        private MeasurementKey m_lastSelectedMeasurement;         #endregion         #region [ Properties ]         /// <summary>        /// Gets or sets output measurements that the action adapter will produce, if any.        /// </summary>        [ConnectionStringParameter,        Description("Defines primary keys of output measurements the action adapter expects; can be one of a filter expression, measurement key, point tag or Guid."),        CustomConfigurationEditor("GSF.TimeSeries.UI.WPF.dll", "GSF.TimeSeries.UI.Editors.MeasurementEditor")]        public override IMeasurement[] OutputMeasurements        {            get            {                return base.OutputMeasurements;            }            set            {                base.OutputMeasurements = value;            }        }         /// <summary>        /// Gets or sets the value that determines whether the adapter should        /// publish measurements if all of its inputs are found to be bad.        /// </summary>        [ConnectionStringParameter,        DefaultValue(DefaultPublishBadValues),        Description("Define the flag that indicates whether this adapter should publish measurements if all inputs are bad.")]        public bool PublishBadValues        {            get            {                return m_publishBadValues;            }            set            {                m_publishBadValues = value;            }        }         /// <summary>        /// Gets or sets the flags that should be considered bad by this adapter.        /// </summary>        [ConnectionStringParameter,        Description("Define the flags that are considered bad by this adapter."),        DefaultValue(DefaultBadFlags)]        public MeasurementStateFlags BadFlags        {            get            {                return m_badFlags;            }            set            {                m_badFlags = value;            }        }         /// <summary>        /// Gets the flag indicating if this adapter considers zero to be a bad value.        /// </summary>        [ConnectionStringParameter,        Description("Define the flag indicating if this adapter considers zero to be a bad value."),        DefaultValue(DefaultHandleZeroAsBad)]        public bool HandleZeroAsBad        {            get            {                return m_handleZeroAsBad;            }            set            {                m_handleZeroAsBad = value;            }        }         /// <summary>        /// Gets the flag indicating if this adapter considers not-a-number to be a bad value.        /// </summary>        [ConnectionStringParameter,        Description("Define the flag indicating if this adapter considers not-a-number to be a bad value."),        DefaultValue(DefaultHandleNaNAsBad)]        public bool HandleNaNAsBad        {            get            {                return m_handleNaNAsBad;            }            set            {                m_handleNaNAsBad = value;            }        }         /// <summary>        /// Gets the flag indicating if this adapter supports temporal processing.        /// </summary>        [ConnectionStringParameter,        Description("Define the flag indicating if this adapter supports temporal processing."),        DefaultValue(DefaultSupportsTemporalProcessing)]        public override bool SupportsTemporalProcessing => m_supportsTemporalProcessing;         /// <summary>        /// Returns the detailed status of the action adapter.        /// </summary>        public override string Status        {            get            {                StringBuilder statusBuilder = new StringBuilder(base.Status);                 IEnumerable<MeasurementStateFlags> badFlags = Enum.GetValues(typeof(MeasurementStateFlags))                    .Cast<MeasurementStateFlags>()                    .Where(flag => flag != MeasurementStateFlags.Normal &&  m_badFlags.HasFlag(flag));                 string badFlagsText = string.Join("," + Environment.NewLine + "                              ", badFlags);                 statusBuilder.AppendLine();                statusBuilder.AppendLine($"          Publish bad values: {(m_publishBadValues ? "Yes" : "No")}");                statusBuilder.AppendLine($"                   Bad Flags: {badFlagsText}");                statusBuilder.AppendLine($"          Handle Zero As Bad: {(m_handleZeroAsBad ? "Yes" : "No")}");                statusBuilder.AppendLine($"           Handle NaN As Bad: {(m_handleNaNAsBad ? "Yes" : "No")}");                statusBuilder.AppendLine($"Supports Temporal Processing: {(m_supportsTemporalProcessing ? "Yes" : "No")}");                statusBuilder.AppendLine($"   Last Selected Measurement: {m_lastSelectedMeasurement}");                 return statusBuilder.ToString();            }        }         #endregion         #region [ Methods ]         /// <summary>        /// Initializes the <see cref="BestValueSelector"/>.        /// </summary>        public override void Initialize()        {            base.Initialize();             if (OutputMeasurements?.Length != 1 && OutputMeasurements?.Length != 2)                throw new ArgumentException($"Exactly one or two output measurement must be defined. Amount defined: {OutputMeasurements?.Length ?? 0}");             Dictionary<string, string> settings = Settings;            string setting;             if (settings.TryGetValue(nameof(PublishBadValues), out setting))                m_publishBadValues = setting.ParseBoolean();            else                m_publishBadValues = DefaultHandleZeroAsBad;             if (!settings.TryGetValue(nameof(BadFlags), out setting) || !Enum.TryParse(setting, out m_badFlags))                m_badFlags = DefaultBadFlags;             if (settings.TryGetValue(nameof(HandleZeroAsBad), out setting))                m_handleZeroAsBad = setting.ParseBoolean();            else                m_handleZeroAsBad = DefaultHandleZeroAsBad;             if (settings.TryGetValue(nameof(HandleNaNAsBad), out setting))                m_handleNaNAsBad = setting.ParseBoolean();            else                m_handleNaNAsBad = DefaultHandleNaNAsBad;             if (settings.TryGetValue(nameof(SupportsTemporalProcessing), out setting))                m_supportsTemporalProcessing = setting.ParseBoolean();            else                m_supportsTemporalProcessing = DefaultSupportsTemporalProcessing;        }         /// <summary>        /// Publish <see cref="IFrame"/> of time-aligned collection of <see cref="IMeasurement"/> values that arrived within the        /// concentrator's defined <see cref="ConcentratorBase.LagTime"/>.        /// </summary>        /// <param name="frame"><see cref="IFrame"/> of measurements with the same timestamp that arrived within <see cref="ConcentratorBase.LagTime"/> that are ready for processing.</param>        /// <param name="index">Index of <see cref="IFrame"/> within a second ranging from zero to <c><see cref="ConcentratorBase.FramesPerSecond"/> - 1</c>.</param>        protected override void PublishFrame(IFrame frame, int index)        {            IMeasurement bestMeasurement = GetBestMeasurement(frame);             if ((object)bestMeasurement == null)                return;             IMeasurement[] newMeasurements = OutputMeasurements                .Select(measurement => Measurement.Clone(measurement))                .ToArray();             newMeasurements[0].Timestamp = frame.Timestamp;            newMeasurements[0].StateFlags = bestMeasurement.StateFlags;            newMeasurements[0].Value = bestMeasurement.Value;             if (newMeasurements.Length > 1)            {                newMeasurements[1].Timestamp = frame.Timestamp;                newMeasurements[1].StateFlags = bestMeasurement.StateFlags;                newMeasurements[1].Value = Array.IndexOf(InputMeasurementKeys, bestMeasurement.Key) + 1;            }             OnNewMeasurements(newMeasurements);             m_lastSelectedMeasurement = bestMeasurement.Key;        }         private IMeasurement GetBestMeasurement(IFrame frame)        {            IMeasurement measurement;             if (m_publishBadValues)            {                return InputMeasurementKeys                    .Select(key => frame.Measurements.TryGetValue(key, out measurement) ? measurement : null)                    .Where(m => (object)m != null)                    .OrderBy(m => (m_handleNaNAsBad && double.IsNaN(m.Value)) ? 1 : 0)                    .ThenBy(m => (m_handleZeroAsBad && m.Value == 0.0D) ? 1 : 0)                    .ThenBy(m => CountFlags(m.StateFlags & m_badFlags))                    .FirstOrDefault();            }             return InputMeasurementKeys                .Select(key => frame.Measurements.TryGetValue(key, out measurement) ? measurement : null)                .Where(m => (object)m != null)                .Where(m => !m_handleNaNAsBad || !double.IsNaN(m.Value))                .Where(m => !m_handleZeroAsBad || m.Value != 0.0D)                .Where(m => (m.StateFlags & m_badFlags) == MeasurementStateFlags.Normal)                .FirstOrDefault();        }         private int CountFlags(MeasurementStateFlags flags)        {            if (flags == MeasurementStateFlags.Normal)                return 0;             uint count = (uint)flags;             count = count - ((count >> 1) & 0x55555555u);            count = ((count >> 2) & 0x33333333u) + (count & 0x33333333u);            count = ((count >> 4) + count) & 0x0F0F0F0Fu;            count = ((count >> 8) + count) & 0x00FF00FFu;            count = ((count >> 16) + count) & 0x0000FFFFu;             return (int)count;        }         #endregion    }}