//******************************************************************************************************//  ControlFile.cs - Gbtc////  Copyright © 2010, 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://www.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://  ----------------------------------------------------------------------------------------------------//  08/01/2014 - J. Ritchie Carroll//       Generated original version of source code.////****************************************************************************************************** using System;using System.Collections.Generic;using System.IO;using System.Linq;using System.Runtime.InteropServices;using System.Text; namespace GSF.EMAX{    /// <summary>    /// Represents an EMAX control file (i.e., a .CTL file).    /// </summary>    public class ControlFile    {        #region [ Members ]         // Fields        public string FileName;        public DataSize DataSize;        public CTL_HEADER Header;        public CTL_FILE_STRUCT[] FileStructures;        public SYSTEM_PARAMETERS SystemParameters;        public SYS_SETTINGS SystemSettings;        public ANALOG_GROUP AnalogGroup;        public EVENT_GROUP EventGroup;        public A_E_RSLTS AnalogEventResults;        public IDENTSTRING IdentityString;        public Dictionary<int, ANLG_CHNL_NEW> AnalogChannelSettings;        public Dictionary<int, EVNT_CHNL_NEW> EventChannelSettings;        public Dictionary<int, double> ScalingFactors;        public EVENT_DISPLAY EventDisplay;        public SENS_RSLTS SensorResults;        public TPwrRcd PowerRecord;        public BoardAnalogEventChannels BoardAnalogEventChannels;        public A_SELECTION AnalogSelection;        public E_GRP_SELECT EventGroupSelection;        public PHASOR_GROUPS PhasorGroups;        public LINE_CONSTANTS LineConstants;        public LINE_NAMES LineNames;        public FAULT_LOCATIONS FaultLocations;        public SEQUENCE_CHANNELS SequenceChannels;        public BREAKER_TRIP_TIMES BreakerTripTimes;         private int[] m_frameLength;        private int m_configuredAnalogChannels;        private readonly List<StructureType> m_parsedSuccesses;        private readonly List<Tuple<StructureType, Exception>> m_parsedFailures;        private StructureType m_currentType;         #endregion         #region [ Constructors ]         /// <summary>        /// Creates a new <see cref="ControlFile"/>.        /// </summary>        public ControlFile()        {            m_parsedSuccesses = new List<StructureType>();            m_parsedFailures = new List<Tuple<StructureType, Exception>>();        }         /// <summary>        /// Creates a new <see cref="ControlFile"/> for the specified <paramref name="fileName"/> and attempts to parse.        /// </summary>        /// <param name="fileName">Control file name.</param>        public ControlFile(string fileName)            : this()        {            FileName = fileName;            Parse();        }         #endregion         #region [ Properties ]         /// <summary>        /// Gets configured analog channels.        /// </summary>        public int ConfiguredAnalogChannels        {            get            {                return m_configuredAnalogChannels;            }        }         /// <summary>        /// Gets the digital channel count for the <see cref="ControlFile"/>.        /// </summary>        public int ConfiguredDigitalChannels        {            get            {                return EventGroupCount * 8;            }        }         /// <summary>        /// Gets the analog channel count for the <see cref="ControlFile"/>.        /// </summary>        public int AnalogChannelCount        {            get            {                ushort samplesPerSecond = SystemParameters.samples_per_second;                return m_configuredAnalogChannels * (samplesPerSecond > 5760 ? samplesPerSecond / 5760 : 1);            }        }         /// <summary>        /// Gets the event group count for the <see cref="ControlFile"/>.        /// </summary>        public int EventGroupCount        {            get            {                if (SystemParameters.samples_per_second > 5760)                    return 4;                 return 4 * (m_configuredAnalogChannels > 32 ? 2 : 1);            }        }         /// <summary>        /// Gets the calculated frame length for the <see cref="ControlFile"/>.        /// </summary>        public int[] FrameLength        {            get            {                // 64 data words + 8 event group words + 8 clock words                const int largeFrame = sizeof(ushort) * 80;                 // 32 data words + 4 event group words + 4 clock words                const int smallFrame = sizeof(ushort) * 40;                 int cardCount;                int remainder;                 if ((object)m_frameLength != null)                    return m_frameLength;                 cardCount = AnalogChannelCount / 64;                remainder = AnalogChannelCount % 64;                 if (remainder > 0)                    cardCount++;                 m_frameLength = Enumerable.Repeat(largeFrame, cardCount).ToArray();                 if (0 < remainder && remainder <= 32)                    m_frameLength[cardCount - 1] = smallFrame;                 return m_frameLength;            }        }         /// <summary>        /// Gets <see cref="StructureType"/> instances that were parsed successfully.        /// </summary>        public IEnumerable<StructureType> ParsedSuccesses        {            get            {                return m_parsedSuccesses;            }        }         /// <summary>        /// Gets <see cref="StructureType"/> instances that failed to parse.        /// </summary>        public IEnumerable<Tuple<StructureType, Exception>> ParsedFailures        {            get            {                return m_parsedFailures;            }        }         #endregion         #region [ Methods ]         /// <summary>        /// Parses the <see cref="ControlFile"/>.        /// </summary>        /// <exception cref="InvalidOperationException">"No EMAX control file name was specified.</exception>        /// <exception cref="FileNotFoundException">EMAX control file was not found.</exception>        public void Parse()        {            if (string.IsNullOrEmpty(FileName))                throw new InvalidOperationException("No EMAX control file name was specified.");             if (!File.Exists(FileName))                throw new FileNotFoundException(string.Format("EMAX control file {0} not found.", FileName));             m_parsedSuccesses.Clear();            m_parsedFailures.Clear();             byte byteValue;             using (FileStream stream = File.OpenRead(FileName))            {                // Read in header and file structure definitions                using (BinaryReader reader = new BinaryReader(stream, Encoding.ASCII, true))                {                    // Read control header                    Header = reader.ReadStructure<CTL_HEADER>();                     // Read byte that defines number of analog channels                    m_configuredAnalogChannels = BinaryCodedDecimal.Decode(Header.id.LowByte());                     // Read byte that defines data size (i.e., 12 or 16 bits)                    byteValue = Header.id.HighByte();                     if (!Enum.IsDefined(typeof(DataSize), byteValue))                        throw new InvalidOperationException("Invalid EMAX data size code encountered: 0x" + byteValue.ToString("X").PadLeft(2, '0'));                     DataSize = (DataSize)byteValue;                     // Create array of file structures                    List<CTL_FILE_STRUCT> fileStructures = new List<CTL_FILE_STRUCT>();                    CTL_FILE_STRUCT fileStructure = new CTL_FILE_STRUCT(reader);                     // ReSharper disable once LoopVariableIsNeverChangedInsideLoop                    while (fileStructure.type != StructureType.EndOfStructures)                    {                        if (fileStructure.type != StructureType.Unknown)                            fileStructures.Add(fileStructure);                         fileStructure = new CTL_FILE_STRUCT(reader);                    }                     FileStructures = fileStructures.ToArray();                }                 // Read in actual file structures                for (int index = 0; index < FileStructures.Length; index++)                {                    CTL_FILE_STRUCT fileStructure = FileStructures[index];                     if (fileStructure.type == StructureType.Unknown)                        continue;                     // Set current type                    m_currentType = fileStructure.type;                     // Locate structure in the file                    stream.Position = fileStructure.offset;                     // Parse the structure type                    using (BinaryReader reader = new BinaryReader(stream, Encoding.ASCII, true))                    {                        switch (m_currentType)                        {                            case StructureType.SYSTEM_PARAMETERS:                                AttemptParse(() => SystemParameters = reader.ReadStructure<SYSTEM_PARAMETERS>());                                break;                            case StructureType.SYS_SETTINGS:                                AttemptParse(() => SystemSettings = reader.ReadStructure<SYS_SETTINGS>());                                break;                            case StructureType.A_E_RSLTS:                                AttemptParse(() => AnalogEventResults = new A_E_RSLTS(reader, m_configuredAnalogChannels, SystemParameters.analog_groups));                                break;                            case StructureType.ANALOG_GROUP:                                AttemptParse(() => AnalogGroup = new ANALOG_GROUP(reader, m_configuredAnalogChannels));                                break;                            case StructureType.EVENT_GROUP:                                AttemptParse(() => EventGroup = reader.ReadStructure<EVENT_GROUP>());                                break;                            case StructureType.ANLG_CHNL_NEW:                                AttemptParse(() =>                                {                                    AnalogChannelSettings = new Dictionary<int, ANLG_CHNL_NEW>();                                    ScalingFactors = new Dictionary<int, double>();                                    ANLG_CHNL_NEW settings;                                     uint nextOffset = (index + 1 < FileStructures.Length) ? FileStructures[index + 1].offset : (uint)stream.Length;                                    uint length = nextOffset - fileStructure.offset;                                    Func<ANLG_CHNL_NEW> channelFactory;                                     if (Marshal.SizeOf<ANLG_CHNL_NEW2>() * ConfiguredAnalogChannels <= length)                                        channelFactory = () => reader.ReadStructure<ANLG_CHNL_NEW2>().ToAnlgChnlNew();                                    else                                        channelFactory = () => reader.ReadStructure<ANLG_CHNL_NEW1>().ToAnlgChnlNew();                                     for (int i = 0; i < ConfiguredAnalogChannels; i++)                                    {                                        settings = channelFactory();                                        AnalogChannelSettings.Add(settings.ChannelNumber, settings);                                        ScalingFactors.Add(settings.ChannelNumber, settings.ScalingFactor);                                    }                                });                                break;                            case StructureType.EVNT_CHNL_NEW:                                AttemptParse(() =>                                {                                    EventChannelSettings = new Dictionary<int, EVNT_CHNL_NEW>();                                    EVNT_CHNL_NEW settings;                                     uint nextOffset = (index + 1 < FileStructures.Length) ? FileStructures[index + 1].offset : (uint)stream.Length;                                    uint length = nextOffset - fileStructure.offset;                                    Func<EVNT_CHNL_NEW> channelFactory;                                     if (Marshal.SizeOf<EVNT_CHNL_NEW2>() * ConfiguredDigitalChannels <= length)                                        channelFactory = () => reader.ReadStructure<EVNT_CHNL_NEW2>().ToEvntChnlNew();                                    else                                        channelFactory = () => reader.ReadStructure<EVNT_CHNL_NEW1>().ToEvntChnlNew();                                     for (int i = 0; i < ConfiguredDigitalChannels; i++)                                    {                                        settings = channelFactory();                                        EventChannelSettings.Add(settings.EventNumber, settings);                                    }                                });                                break;                            case StructureType.ANLG_CHNLS:                                // TODO: Add decoder once structure definition is known...                                m_parsedFailures.Add(new Tuple<StructureType, Exception>(m_currentType, new NotImplementedException()));                                break;                            case StructureType.SHORT_HEADER:                                // TODO: Add decoder once structure definition is known...                                m_parsedFailures.Add(new Tuple<StructureType, Exception>(m_currentType, new NotImplementedException()));                                break;                            case StructureType.FAULT_HEADER:                                // TODO: Add decoder once structure definition is known...                                m_parsedFailures.Add(new Tuple<StructureType, Exception>(m_currentType, new NotImplementedException()));                                break;                            case StructureType.EVENT_DISPLAY:                                AttemptParse(() => EventDisplay = new EVENT_DISPLAY(reader, SystemParameters.event_groups));                                break;                            case StructureType.IDENTSTRING:                                AttemptParse(() =>                                {                                    IdentityString = reader.ReadStructure<IDENTSTRING>();                                    IdentityString.value.TruncateRight(IdentityString.length);                                });                                break;                            case StructureType.A_SELECTION:                                AttemptParse(() => AnalogSelection = new A_SELECTION(reader));                                break;                            case StructureType.E_GROUP_SELECT:                                AttemptParse(() => EventGroupSelection = new E_GRP_SELECT(reader));                                break;                            case StructureType.PHASOR_GROUP:                                AttemptParse(() => PhasorGroups = new PHASOR_GROUPS(reader));                                break;                            case StructureType.LINE_CONSTANTS:                                AttemptParse(() => LineConstants = new LINE_CONSTANTS(reader));                                break;                            case StructureType.LINE_NAMES:                                AttemptParse(() => LineNames = new LINE_NAMES(reader));                                break;                            case StructureType.FAULT_LOCATION:                                AttemptParse(() => FaultLocations = new FAULT_LOCATIONS(reader));                                break;                            case StructureType.SENS_RSLTS:                                AttemptParse(() => SensorResults = reader.ReadStructure<SENS_RSLTS>());                                break;                            case StructureType.SEQUENCE_CHANNELS:                                AttemptParse(() => SequenceChannels = new SEQUENCE_CHANNELS(reader));                                break;                            case StructureType.TPwrRcd:                                AttemptParse(() => PowerRecord = reader.ReadStructure<TPwrRcd>());                                break;                            case StructureType.BoardAnalogEventChannels:                                AttemptParse(() => BoardAnalogEventChannels = reader.ReadStructure<BoardAnalogEventChannels>());                                break;                            case StructureType.BREAKER_TRIP_TIMES:                                AttemptParse(() => BreakerTripTimes = new BREAKER_TRIP_TIMES(reader, m_configuredAnalogChannels, SystemParameters.analog_groups));                                break;                            default:                                throw new ArgumentOutOfRangeException();                        }                    }                }            }        }         private void AttemptParse(Action parseAction)        {            try            {                parseAction();                m_parsedSuccesses.Add(m_currentType);            }            catch (Exception ex)            {                m_parsedFailures.Add(new Tuple<StructureType, Exception>(m_currentType, ex));            }        }         #endregion         #region [ Old Code ]         //private readonly StructureType[] StructureTypeProcessingOrder =         //{        //    StructureType.SYSTEM_PARAMETERS,        //    StructureType.SYS_SETTINGS,        //    StructureType.A_E_RSLTS,        //    StructureType.ANALOG_GROUP,        //    StructureType.EVENT_GROUP,        //    StructureType.ANLG_CHNL_NEW,        //    StructureType.EVNT_CHNL_NEW,        //    StructureType.ANLG_CHNLS,        //    StructureType.SHORT_HEADER,        //    StructureType.FAULT_HEADER,        //    StructureType.EVENT_DISPLAY,        //    StructureType.IDENTSTRING,        //    StructureType.A_SELECTION,        //    StructureType.E_GROUP_SELECT,        //    StructureType.PHASOR_GROUP,        //    StructureType.LINE_CONSTANTS,        //    StructureType.LINE_NAMES,        //    StructureType.FAULT_LOCATION,        //    StructureType.SENS_RSLTS,        //    StructureType.SEQUENCE_CHANNELS,        //    StructureType.TPwrRcd,        //    StructureType.BoardAnalogEventChannels,        //    StructureType.Unknown,        //    StructureType.EndOfStructures        //};         //Debug.Assert(StructureTypeProcessingOrder.Length == Enum.GetValues(typeof(StructureType)).Length, "StructureTypeProcessOrder is not the same length as StructureType enumeration!");         //// Sort file structures in desired processing order        //Func<StructureType, int> getProcessingOrder = structureType => Array.IndexOf(StructureTypeProcessingOrder, structureType);         //fileStructures.Sort((x, y) =>        //{        //    int indexX = getProcessingOrder(x.type);        //    int indexY = getProcessingOrder(y.type);        //    return indexX < indexY ? -1 : indexX > indexY ? 1 : 0;        //});         #endregion    }}