//******************************************************************************************************//  Parser.cs - Gbtc////  Copyright © 2012, 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://  ----------------------------------------------------------------------------------------------------//  06/17/2012 - J. Ritchie Carroll//       Generated original version of source code.//  12/13/2012 - Starlynn Danyelle Gilliam//       Modified Header.////****************************************************************************************************** using System;using System.IO;using System.Linq;using GSF.IO; namespace GSF.EMAX{    /// <summary>    /// EMAX data file(s) parser.    /// </summary>    public class Parser : IDisposable    {        #region [ Members ]         // Fields        private ControlFile m_controlFile;        private string m_fileName;        private bool m_disposed;        private FileStream[] m_fileStreams;        private DateTime m_timestamp;        private double[] m_values;        private ushort[] m_eventGroups;        private DateTime m_baseTime;        private TimeZoneInfo m_sourceTimeZone;        private bool m_timeError;         #endregion         #region [ Constructors ]         /// <summary>        /// Releases the unmanaged resources before the <see cref="Parser"/> object is reclaimed by <see cref="GC"/>.        /// </summary>        ~Parser()        {            Dispose(false);        }         #endregion         #region [ Properties ]         /// <summary>        /// Gets or sets associated EMAX control file for this <see cref="Parser"/>.        /// </summary>        /// <remarks>        /// This is similar in function to a COMTRADE schema file.        /// </remarks>        public ControlFile ControlFile        {            get            {                return m_controlFile;            }            set            {                m_controlFile = value;                 if ((object)m_controlFile != null)                {                    if (m_controlFile.AnalogChannelCount > 0)                        m_values = new double[m_controlFile.AnalogChannelCount];                    else                        throw new InvalidOperationException("Invalid control file: total analog channels defined in control file is zero.");                     if (m_controlFile.EventGroupCount > 0)                        m_eventGroups = new ushort[m_controlFile.EventGroupCount];                    else                        throw new InvalidOperationException("Invalid control file: total event groups defined in control file is zero.");                     SYSTEM_PARAMETERS systemParameters = m_controlFile.SystemParameters;                     m_baseTime = systemParameters.FaultTime.BaselinedTimestamp(BaselineTimeInterval.Year);                    m_sourceTimeZone = systemParameters.GetTimeZoneInfo();                }                else                {                    m_values = null;                }            }        }         /// <summary>        /// Gets or sets EMAX data filename.        /// </summary>        /// <remarks>        /// If there are more than one data files in a set (e.g., RCL/RCU), this should be set to first file name in the set, e.g., DATA123.RCL.        /// </remarks>        public string FileName        {            get            {                return m_fileName;            }            set            {                m_fileName = value;            }        }         /// <summary>        /// Gets timestamp of current record in the timezone of provided IRIG signal.        /// </summary>        public DateTime Timestamp        {            get            {                return m_timestamp;            }        }         /// <summary>        /// Gets a flag that indicates whether the parser encountered an error        /// while parsing the timestamp in the last call to <see cref="ReadNext"/>.        /// </summary>        public bool TimeError        {            get            {                return m_timeError;            }        }         /// <summary>        /// Attempts to get current timestamp converted to UTC.        /// </summary>        /// <remarks>        /// This will only be accurate if timezone configured in device matches IRIG clock.        /// </remarks>        public DateTime TimestampAsUtc        {            get            {                return TimeZoneInfo.ConvertTimeToUtc(m_timestamp, m_sourceTimeZone);            }        }         /// <summary>        /// Gets values of current record.        /// </summary>        public double[] Values        {            get            {                return m_values;            }        }         /// <summary>        /// Gets event groups for current record.        /// </summary>        public ushort[] EventGroups        {            get            {                return m_eventGroups;            }        }         // Gets total number of offset bytes in the file        private int OffsetBytes        {            get            {                return m_controlFile.SystemParameters.channel_offset * 2;            }        }         #endregion         #region [ Methods ]         /// <summary>        /// Releases all the resources used by the <see cref="Parser"/> object.        /// </summary>        public void Dispose()        {            Dispose(true);            GC.SuppressFinalize(this);        }         /// <summary>        /// Releases the unmanaged resources used by the <see cref="Parser"/> object and optionally releases the managed resources.        /// </summary>        /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>        protected virtual void Dispose(bool disposing)        {            if (!m_disposed)            {                try                {                    if (disposing)                    {                        CloseFiles();                    }                }                finally                {                    m_disposed = true;  // Prevent duplicate dispose.                }            }        }         /// <summary>        /// Opens all EMAX data file streams.        /// </summary>        public void OpenFiles()        {            if (string.IsNullOrWhiteSpace(m_fileName))                throw new InvalidOperationException("Initial EMAX data file name was not specified, cannot open file(s).");             if (!File.Exists(m_fileName))                throw new FileNotFoundException(string.Format("Specified EMAX data file \"{0}\" was not found, cannot open file(s).", m_fileName));             string extension = FilePath.GetExtension(m_fileName);            string[] fileNames;             if (extension.Equals(".RCU", StringComparison.OrdinalIgnoreCase))                throw new InvalidOperationException("Please specify the .RCL file instead of the .RCU as the initial file - the .RCU will be automatically loaded: " + m_fileName);             if (extension.Equals(".RCD", StringComparison.OrdinalIgnoreCase))            {                // RCD files mean there is only one card in the system                fileNames = new string[1];                fileNames[0] = m_fileName;            }            else if (extension.Equals(".RCL", StringComparison.OrdinalIgnoreCase))            {                // RCL files mean there are two cards in the system - one low (RCL) and one high (RCU)                fileNames = new string[2];                fileNames[0] = m_fileName;                fileNames[1] = Path.Combine(FilePath.GetDirectoryName(m_fileName), FilePath.GetFileNameWithoutExtension(m_fileName) + ".RCU");            }            else            {                throw new InvalidOperationException("Specified file name does not have a valid EMAX extension: " + m_fileName);            }             // Create a new file stream for each file            m_fileStreams = new FileStream[fileNames.Length];             for (int i = 0; i < fileNames.Length; i++)                m_fileStreams[i] = new FileStream(fileNames[i], FileMode.Open, FileAccess.Read, FileShare.Read);        }         /// <summary>        /// Closes all EMAX data file streams.        /// </summary>        public void CloseFiles()        {            if ((object)m_fileStreams != null)            {                foreach (FileStream fileStream in m_fileStreams)                {                    if ((object)fileStream != null)                    {                        fileStream.Close();                        fileStream.Dispose();                    }                }            }             m_fileStreams = null;        }         /// <summary>        /// Reads next EMAX record.        /// </summary>        /// <returns><c>true</c> if read succeeded; otherwise <c>false</c> if end of data set was reached.</returns>        public bool ReadNext()        {            if ((object)m_fileStreams == null)                throw new InvalidOperationException("EMAX data files are not open, cannot read next record.");             if ((object)m_controlFile == null)                throw new InvalidOperationException("No EMAX schema has been defined, cannot read records.");             byte[] buffer = null;             FileStream currentFile;            int recordLength;            ushort[] clockWords = new ushort[4];            ushort value;            int index;            double scalingFactor;             for (int streamIndex = 0; streamIndex < m_fileStreams.Length; streamIndex++)            {                currentFile = m_fileStreams[streamIndex];                recordLength = m_controlFile.FrameLength[streamIndex];                index = 4;                 if ((object)buffer == null || buffer.Length < recordLength)                    buffer = new byte[recordLength];                 // Read next record from file                int bytesRead = currentFile.Read(buffer, 0, recordLength);                 if (bytesRead == 0)                    return false;                 if (bytesRead == recordLength)                {                    int start = streamIndex * 64;                    int end = Math.Min(start + 64, m_values.Length);                     // Parse all analog record values                    for (int i = start; i < end; i++)                    {                        // Read next value                        value = LittleEndian.ToUInt16(buffer, index);                         if (m_controlFile.ScalingFactors.TryGetValue(i, out scalingFactor))                        {                            if (value >= 32768)                                m_values[i] = (65535 - value) / 32768.0D * scalingFactor;                            else                                m_values[i] = -value / 32768.0D * scalingFactor;                        }                        else if (m_controlFile.DataSize == DataSize.Bits12)                        {                            m_values[i] = value >> 4;                        }                        else                        {                            m_values[i] = value;                        }                         index += 2;                    }                     // There are always either 32 or 64 data words depending on the number of configured channels                    index = (m_controlFile.AnalogChannelCount <= 32) ? 32 : 64;                    index *= sizeof(ushort);                     // Read event group values (first set)                    for (int i = 0; i < 4; i++)                    {                        m_eventGroups[i] = LittleEndian.ToUInt16(buffer, index);                        index += 2;                    }                     // Read timestamp from next four word values                    for (int i = 0; i < 4; i++)                    {                        clockWords[i] = LittleEndian.ToUInt16(buffer, index);                        index += 2;                    }                     m_timestamp = ParseTimestamp(clockWords);                     if (ControlFile.ConfiguredAnalogChannels > 32 && ControlFile.SystemSettings.samples_per_second <= 5760)                    {                        // Read next set of event group values                        for (int i = 4; i < 8; i++)                        {                            m_eventGroups[i] = LittleEndian.ToUInt16(buffer, index);                            index += 2;                        }                    }                }                else                {                    throw new InvalidOperationException("Failed to read enough bytes from EMAX file for a record as defined by control file - possible control file/data file mismatch or file corruption.");                }            }             return true;        }         private DateTime ParseTimestamp(ushort[] clockWords)        {            if ((object)clockWords == null)                throw new NullReferenceException("Clock words array was null - cannot parse timestamp");             if (clockWords.Length != 4)                throw new InvalidOperationException("Clock words array must have four values - cannot parse timestamp");             int days, hours, minutes, seconds, milliseconds, microseconds;            byte highByte, lowByte;             m_timeError = clockWords.All(clockWord => clockWord == 0xFFFF);             if (m_timeError)                return DateTime.MaxValue;             highByte = clockWords[0].HighByte();            lowByte = clockWords[0].LowByte();             days = highByte.HighNibble() * 100 + highByte.LowNibble() * 10 + lowByte.HighNibble();            hours = lowByte.LowNibble() * 10;             highByte = clockWords[1].HighByte();            lowByte = clockWords[1].LowByte();             hours += highByte.HighNibble();            minutes = highByte.LowNibble() * 10 + lowByte.HighNibble();            seconds = lowByte.LowNibble() * 10;             highByte = clockWords[2].HighByte();            lowByte = clockWords[2].LowByte();             seconds += highByte.HighNibble();             milliseconds = highByte.LowNibble() * 100 + lowByte.HighNibble() * 10 + lowByte.LowNibble();             if (milliseconds > 999)                milliseconds = 0;             highByte = clockWords[3].HighByte();            lowByte = clockWords[3].LowByte();             microseconds = highByte.HighNibble() * 100 + highByte.LowNibble() * 10 + lowByte.HighNibble();             if (microseconds > 999)                microseconds = 0;             return m_baseTime                    .AddDays(days - 1) // Base time starts at day one, so we subtract one for target day                    .AddHours(hours)                    .AddMinutes(minutes)                    .AddSeconds(seconds)                    .AddMilliseconds(milliseconds)                    .AddTicks(Ticks.FromMicroseconds(microseconds));        }         #endregion    }}