aswi2021tri-musketyri-gitlab/Server/ServerApp/Parser/Parsers/WeatherParser.cs @ master

//
// Author: A. Konig
//

using log4net;
using ServerApp.Parser.InputData;
using ServerApp.Parser.OutputInfo;
using System;
using System.Collections.Generic;
using System.IO;

namespace ServerApp.Parser.Parsers
{
    /// <summary>
    /// Class parsing weather files into instances of WeatherInfo divided by given time interval
    /// Data parsed from 7am (included) to 18pm (included)
    /// </summary>
    /// <author>A. Konig</author>
    public class WeatherParser
    {
        /// <summary> Logger </summary>
        private static readonly ILog _log = LogManager.GetLogger(typeof(WeatherParser));

        /// <summary> Datafile loader  </summary>
        IDataLoader loader;

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="loader">Datafile loader</param>
        public WeatherParser(IDataLoader loader)
        {
            this.loader = loader;
        }

        /// <summary>
        /// Parses weather data to WeatherInfo instances
        /// Data parsed from 7am (included) to 18pm (included)
        /// </summary>
        /// <param name="weatherFiles">Paths to files with weather data files</param>
        /// <param name="endTime">End time of related data</param>
        /// <param name="startTime">Start time of related data</param>
        /// <param name="wholeDay">Should data be parsed as one instance per day (if true parameter interval will be ignored)</param>
        /// <param name="interval">Time interval to divide days by, minimum is 1h</param>
        /// <returns></returns>
        public List<WeatherInfo> ParseWeatherData(List<string> weatherFiles, DateTime startTime, DateTime endTime, bool wholeDay = true, int interval = 1)
        {
            List<WeatherInfo> list = new List<WeatherInfo>();

            if (weatherFiles == null || interval <= 0)
                return list;

            string current = "";
            try
            {
                // get all files in folder
                foreach (string fileName in weatherFiles)
                {
                    current = fileName;

                    if (!File.Exists(fileName))
                        continue;

                    // parse as one instance per day
                    List<WeatherInfo> loadedData = null;
                    if (wholeDay)
                        loadedData = ProcessOneWeatherFileAsDays(fileName, startTime, endTime);
                    // parse according to interval
                    else
                    {
                        loadedData = ProcessOneWeatherFileAsIntervals(fileName, interval, startTime, endTime);
                    }

                    list.AddRange(loadedData);
                }
            } catch
            {
                _log.Error("Incorrect Weather input file " + current);
            }

            return list;
        }

        /// <summary>
        /// Parses data from one data file as one instance per day
        /// </summary>
        /// <param name="path">Path ti file</param>
        /// <param name="endTime">End time of related data</param>
        /// <param name="startTime">Start time of related data</param>
        /// <returns>List with WeatherInfo instances</returns>
        private List<WeatherInfo> ProcessOneWeatherFileAsDays(string path, DateTime startTime, DateTime endTime)
        {
            List<WeatherInfo> weatherInfo = new List<WeatherInfo>();

            List<WeatherInstance> list = loader.LoadWeatherFile(path);
            if (list == null || list.Count == 0)
                return weatherInfo;

            // array with data [temp, rain, wind, lum]
            double[] recordedAmount = new double[4];
            // min/max hour taken into account
            int[] minmaxHour = new int[] { 7, 18 };
            // interval length
            int range = minmaxHour[1] - minmaxHour[0];

            // first day
            DateTime lastStartDay = new DateTime(list[0].dateTime.Year, list[0].dateTime.Month, list[0].dateTime.Day, minmaxHour[0], 0, 0);
            // number of values in day
            int values = 0, weatherValues = 0;
            for (int i = 0; i < list.Count; i++)
            {
                int currHour = list[i].dateTime.Hour;
                if (currHour < minmaxHour[0] || currHour > minmaxHour[1])
                    continue;

                // start of new day -> make a new instance
                DateTime date = new DateTime(list[i].dateTime.Year, list[i].dateTime.Month, list[i].dateTime.Day, minmaxHour[0], 0, 0);
                if (!date.Equals(lastStartDay))
                {
                    WeatherInfo dayInfo = new WeatherInfo(lastStartDay, recordedAmount[0] / values, (int)(recordedAmount[1] / values * 100), recordedAmount[2] / values, recordedAmount[3] / weatherValues, range); 
                    weatherInfo.Add(dayInfo);

                    recordedAmount = new double[4];
                    lastStartDay = date;
                    values = 0;
                    weatherValues = 0;
                }

                // if not in allowed time window -> discard
                if (list[i].dateTime < startTime || list[i].dateTime > endTime)
                {
                    continue;
                }

                // aggregate data
                recordedAmount[0] += list[i].temp;
                recordedAmount[1] += list[i].rain;
                recordedAmount[2] += list[i].wind;

                if (ValueToConditions.TransferLuxToConditions(list[i].lum * 1000) != WeatherConditions.Dark)
                {
                    recordedAmount[3] += list[i].lum * 1000; weatherValues++;
                }

                values++;
            }

            // data from last day
            if (values != 0)
            {
                WeatherInfo dayInfo2 = new WeatherInfo(lastStartDay, recordedAmount[0] / values, (int)(recordedAmount[1] / values * 100), recordedAmount[2] / values, recordedAmount[3] / weatherValues, range);
                weatherInfo.Add(dayInfo2);
            }

            return weatherInfo;
        }

        /// <summary>
        /// Parses data from one data file as one instance per interval length
        /// </summary>
        /// <param name="path">Path to file</param>
        /// <param name="interval">Interval length</param>
        /// <param name="endTime">End time of related data</param>
        /// <param name="startTime">Start time of related data</param>
        /// <returns>List with ActivityInfo instances</returns>
        private List<WeatherInfo> ProcessOneWeatherFileAsIntervals(string path, int interval, DateTime startTime, DateTime endTime)
        {
            List<WeatherInfo> weatherInfo = new List<WeatherInfo>();

            List<WeatherInstance> list = loader.LoadWeatherFile(path);
            if (list == null || list.Count == 0)
                    return weatherInfo;

            // min/max hour taken into account
            int[] minmaxHour = new int[] { 7, 18 };
            int range = minmaxHour[1] - minmaxHour[0];

            if (interval > range)
                return null;

            int indices = (int)Math.Ceiling(range / (double)interval);
            int[] to = new int[indices];
            double[][] data = new double[indices][];
            int[] count = new int[indices];
            for (int i = 0; i < to.Length; i++)
            {
                to[i] = minmaxHour[0] + interval * (i + 1);
                data[i] = new double[4];
                count[i] = 0;
            }

            // first day
            DateTime lastStartTime = new DateTime(list[0].dateTime.Year, list[0].dateTime.Month, list[0].dateTime.Day, minmaxHour[0], 0, 0);
            int index;
            for (int i = 0; i < list.Count; i++)
            {
                int currHour = list[i].dateTime.Hour;
                if (currHour < minmaxHour[0] || currHour > minmaxHour[1])
                    continue;

                // start of the day -> make an instance
                DateTime date = new DateTime(list[i].dateTime.Year, list[i].dateTime.Month, list[i].dateTime.Day, list[i].dateTime.Hour, 0, 0);

                // end of the day
                if (!(date.Year == lastStartTime.Year && date.Month == lastStartTime.Month && date.Day == lastStartTime.Day))
                {
                    // note down all aggregated data
                    for (int k = 0; k < to.Length; k++)
                    {
                        int raincount = 0;
                        double rainval = 0;;
                        for (int l = 0; l <= k; l++)
                        {
                            raincount += count[l];
                            rainval += data[l][1];
                        }

                        DateTime stTime = new DateTime(lastStartTime.Year, lastStartTime.Month, lastStartTime.Day, to[k] - interval, 0, 0);

                        WeatherInfo intervalInfo = new WeatherInfo(stTime, data[k][0] / count[k], (int)((rainval / raincount) * 100), data[k][2] / count[k], data[k][3] / count[k], interval);
                        if (count[k] != 0)
                            weatherInfo.Add(intervalInfo);

                    }

                    lastStartTime = date;
                    count = new int[indices];
                    for (int l = 0; l < data.Length; l++)
                    {
                        data[l] = new double[4];
                        count[l] = 0;
                    }
                }

                // if not in allowed time window -> discard
                if (list[i].dateTime < startTime || list[i].dateTime > endTime)
                    continue;

                // find index for current instance
                index = 0;
                for (int k = 1; k < to.Length; k++)
                {
                    if (to[k] > list[i].dateTime.Hour && to[k - 1] <= list[i].dateTime.Hour)
                    {
                        index = k;
                        break;
                    }
                }

                // aggregate data
                data[index][0] += list[i].temp;
                data[index][1] += list[i].rain;
                data[index][2] += list[i].wind;
                data[index][3] += list[i].lum * 1000;
                count[index]++;

            }

            for (int k = 0; k < to.Length; k++)
            {
                int raincount = 0;
                double rainval = 0; ;
                for (int l = 0; l <= k; l++)
                {
                    raincount += count[l];
                    rainval += data[l][1];
                }

                DateTime stTime = new DateTime(lastStartTime.Year, lastStartTime.Month, lastStartTime.Day, to[k] - interval, 0, 0);

                WeatherInfo intervalInfo = new WeatherInfo(stTime, data[k][0] / count[k], (int)((rainval / raincount) * 100), data[k][2] / count[k], data[k][3] / count[k], interval);
                if (count[k] != 0)
                    weatherInfo.Add(intervalInfo);
            }

            return weatherInfo;
        }
    }

}