//******************************************************************************************************//  CorrectiveParser.cs - Gbtc////  Copyright © 2014, 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://  ----------------------------------------------------------------------------------------------------//  12/18/2014 - Stephen C. Wills//       Generated original version of source code.////****************************************************************************************************** using System;using System.Linq; namespace GSF.EMAX{    /// <summary>    /// EMAX data file(s) parser that calculates timestamps based    /// on sample rate and attempts to correct inverted values.    /// </summary>    public class CorrectiveParser : IDisposable    {        #region [ Members ]         // Fields        private Parser m_parser;         private DateTime m_currentSecond;        private Ticks[] m_subsecondDistribution;        private int m_currentIndex;         private DateTime m_calculatedTimestamp;        private double[] m_correctedValues;         private TimeZoneInfo m_sourceTimeZone;         private bool m_disposed;         #endregion         #region [ Constructors ]         /// <summary>        /// Creates a new instance of the <see cref="CorrectiveParser"/> class.        /// </summary>        public CorrectiveParser()        {            m_parser = new Parser();        }         #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_parser.ControlFile;            }            set            {                m_parser.ControlFile = value;                 if ((object)value != null)                {                    m_correctedValues = new double[Values.Length];                    m_sourceTimeZone = value.SystemParameters.GetTimeZoneInfo();                }                else                {                    m_correctedValues = 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_parser.FileName;            }            set            {                m_parser.FileName = value;            }        }         /// <summary>        /// Gets timestamp of current record, parsed from the file, in the timezone of provided IRIG signal.        /// </summary>        public DateTime ParsedTimestamp        {            get            {                return m_parser.Timestamp;            }        }         /// <summary>        /// Attempts to get current timestamp, parsed from the file, converted to UTC.        /// </summary>        /// <remarks>        /// This will only be accurate if timezone configured in device matches IRIG clock.        /// </remarks>        public DateTime ParsedTimestampAsUtc        {            get            {                return TimeZoneInfo.ConvertTimeToUtc(m_calculatedTimestamp, m_sourceTimeZone);            }        }         /// <summary>        /// Gets calculated timestamp of current record in the timezone of provided IRIG signal.        /// </summary>        public DateTime CalculatedTimestamp        {            get            {                return m_calculatedTimestamp;            }        }         /// <summary>        /// Attempts to get calculated timestamp of current record converted to UTC.        /// </summary>        /// <remarks>        /// This will only be accurate if timezone configured in device matches IRIG clock.        /// </remarks>        public DateTime CalculatedTimestampAsUtc        {            get            {                return TimeZoneInfo.ConvertTimeToUtc(m_calculatedTimestamp, m_sourceTimeZone);            }        }         /// <summary>        /// Gets values of current record.        /// </summary>        public double[] Values        {            get            {                return m_parser.Values;            }        }         /// <summary>        /// Gets corrected values, which may be inverted based on the difference        /// between the calculated timestamp and the parsed timestamp.        /// </summary>        public double[] CorrectedValues        {            get            {                return m_correctedValues;            }        }         /// <summary>        /// Gets event groups for current record.        /// </summary>        public ushort[] EventGroups        {            get            {                return m_parser.EventGroups;            }        }         #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()        {            long previousMilliseconds;            long milliseconds;            int count;             int sampleRate;            int distributionIndex;             m_parser.OpenFiles();             sampleRate = m_parser.ControlFile.SystemParameters.samples_per_second;            m_subsecondDistribution = Ticks.SubsecondDistribution(sampleRate);             using (Parser parser = new Parser())            {                parser.ControlFile = m_parser.ControlFile;                parser.FileName = m_parser.FileName;                 // Open EMAX data file                parser.OpenFiles();                 m_currentSecond = DateTime.MinValue;                previousMilliseconds = -1;                milliseconds = 0;                count = 0;                 while (parser.ReadNext())                {                    if (parser.TimeError)                        continue;                     // Set currentSecond to this frame's timestamp                    m_currentSecond = parser.Timestamp;                     // Get total milliseconds since epoch                    milliseconds = m_currentSecond.Ticks / Ticks.PerMillisecond;                     // If the milliseconds are exactly one millisecond greater than the previous                    // timestamp's milliseconds, we can accurately find the timestamp of this frame                    if (previousMilliseconds > 0 && milliseconds - previousMilliseconds == 1)                        break;                     // Update previousMilliseconds and count                    previousMilliseconds = milliseconds;                    count++;                }                 if (m_currentSecond == DateTime.MinValue)                {                    // If there was an error reading the timestamps in the parser,                    // calculate the timestamp from the data in the control file                    TimeZoneInfo tzInfo = parser.ControlFile.SystemParameters.GetTimeZoneInfo();                    DateTime faultTime = parser.ControlFile.SystemParameters.FaultTime;                    string daylightName = parser.ControlFile.SystemParameters.time_zone_information.DaylightName;                    short faultMilliseconds = parser.ControlFile.SystemParameters.mS_time;                    short prefaultSamples = parser.ControlFile.SystemParameters.prefault_samples;                    short startOffsetSamples = parser.ControlFile.SystemParameters.start_offset_samples;                     // Set currentSecond to the timestamp of the first frame                    m_currentSecond = faultTime.AddMilliseconds(faultMilliseconds).AddSeconds(-(prefaultSamples + startOffsetSamples) / (double)sampleRate);                     // Get total milliseconds since epoch                    milliseconds = m_currentSecond.Ticks / Ticks.PerMillisecond;                     // Timestamps in the control file are stored in UTC (or close to it),                    // but it seems that sometimes EMAX adjusts timestamps without applying DST                    // rules so we use the DaylightName of the time zone info as a sanity check                    // and fall back on the BaseUtcOffset property in these weird cases                    if (daylightName == tzInfo.DaylightName || daylightName != tzInfo.Id)                        m_currentSecond = TimeZoneInfo.ConvertTimeFromUtc(m_currentSecond, tzInfo);                    else                        m_currentSecond += tzInfo.BaseUtcOffset;                     m_currentSecond = DateTime.SpecifyKind(m_currentSecond, DateTimeKind.Unspecified);                }                 // Remove subseconds from currentSecond                m_currentSecond = m_currentSecond.AddTicks(-(m_currentSecond.Ticks % Ticks.PerSecond));                 // Get the milliseconds since the top of the second                milliseconds %= 1000;                 // This should get very near to the index of the                // desired value in the subsecond distribution                distributionIndex = ((int)milliseconds * sampleRate) / 1000;                 // Scan forward in the subsecond distribution until we are sure we've found the correct index                while ((long)m_subsecondDistribution[distributionIndex].ToMilliseconds() != milliseconds)                    distributionIndex++;                 // Set currentIndex to the index in the distribution of the first timestamp in this file                m_currentIndex = distributionIndex - count;                 // Subtract seconds from currentSecond and add the equivalent number of indexes                // to currentIndex until currentIndex is greater than or equal to zero                while (m_currentIndex < 0)                {                    m_currentSecond = m_currentSecond.AddSeconds(-1.0D);                    m_currentIndex += sampleRate;                }            }        }         /// <summary>        /// Closes all EMAX data file streams.        /// </summary>        public void CloseFiles()        {            if ((object)m_parser != null)            {                m_parser.Dispose();                m_parser = 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()        {            double frequency;            double diff;            int halfCycles;             if (m_parser.ReadNext())            {                // Calculate the timestamp                m_calculatedTimestamp = m_currentSecond.AddTicks(m_subsecondDistribution[m_currentIndex]);                 if (!m_parser.TimeError)                {                    // Correct the values                    frequency = m_parser.ControlFile.SystemParameters.frequency;                    diff = Math.Abs(m_calculatedTimestamp.Subtract(m_parser.Timestamp).TotalSeconds);                    halfCycles = (int)Math.Round(diff * frequency * 2.0D);                     if (halfCycles % 2 == 0)                        Array.Copy(Values, m_correctedValues, m_correctedValues.Length);                    else                        Values.Select(v => -v).ToList().CopyTo(m_correctedValues);                }                else                {                    // We can't determine whether the values need correction                    // without a proper timestamp from the underlying parser                    Array.Copy(Values, m_correctedValues, m_correctedValues.Length);                }                 // Move to the next subsecond in the distribution                m_currentIndex++;                 if (m_currentIndex == m_subsecondDistribution.Length)                {                    // If we reach the end of the subsecond distribution,                    // add one to currentSecond and reset the currentIndex to zero                    m_currentSecond = m_currentSecond.AddSeconds(1.0D);                    m_currentIndex = 0;                }                 return true;            }             return false;        }         #endregion    }}