path: root/Software/Visual_Studio/Utilities/Tango.DispenserAnalyzer.UI/Analyzers/FlowAnalyser.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.DispenserAnalyzer.UI.Analysis;
using Tango.DispenserAnalyzer.UI.Models;
using MathNet.Numerics.LinearAlgebra;
using System.Linq.Expressions;
using System.Diagnostics;
using OxyPlot;
using System.Collections.ObjectModel;
using Tango.Documents;
using System.IO;
using Tango.Core.Helpers;

namespace Tango.DispenserAnalyzer.UI.Analyzers
{
    [Analyzer("flow")]
   
    public class FlowAnalyser : IDispenserDispenserAnalyser
    {
        private IReader<DispenserSample> _reader;
        public IReader<DispenserSample> Reader
        {
            get { return _reader; }
            set { _reader = value; }
        }
        

        public FlowAnalyser()
        {
            Reader = new DispenserReader();
        }

        public Task<List<IAnalyzerResult>> Process(List<DispenserSample> csvRows, bool backgroundMode)
        {
            return Task.Factory.StartNew<List<IAnalyzerResult>>(() =>
            {
                List<IAnalyzerResult> results = new List<IAnalyzerResult>();
                List<DispenserSample> commands = csvRows.Where(x => x.Command != null && x.Command.ToLower().Contains("label")).ToList<DispenserSample>();
                var pairs = commands.Select((x, i) => new { Index = i, Value = x }).GroupBy(x => x.Index/2 ).Select(x => x.Select(v => v.Value).ToList()).ToList();
                MovingAverageFilter filter = new MovingAverageFilter();
                int flowtestNumber = 0;
                for (int index = 0; index < pairs.Count(); index++)
                {
                    var pair = pairs[index];
                    if (pair.Count != 2)
                        continue;

                    List<DispenserSample> rangeTestValues = csvRows.Where(x => x.Index > pair[0].Index && x.Index < pair[1].Index).ToList();

                    if (index % 2 == 1)//testing Flow-error
                    {

                       List<DispenserSample> filteredValues = rangeTestValues.Skip((int)Settings.GetValueByName(AnalyzerSettingsEnum.ExcludeAnalysis)).ToList();
                        
                        //Move Average data
                        List<Task> tasks = new List<Task>();
                        int calc_count = (int)filteredValues.Count() / 4;
                        int start_index = 0;
                        while (start_index < filteredValues.Count())
                        {
                            int calc_amount = (start_index + calc_count) >= (filteredValues.Count() - 4) ? filteredValues.Count() - start_index : calc_count;
                            var source_filter = filteredValues.Skip(start_index).Take(calc_amount).ToList();
                            tasks.Add(Task.Run(() =>
                            {
                                filter.Filtering(source_filter);
                            }));
                            start_index += calc_amount;
                        }
                        Task.WaitAll(tasks.ToArray());

                        //calculate difference Max Min values for each 300 values
                        int periodCalcMaxMin = (int)Settings.GetValueByName(AnalyzerSettingsEnum.MaxMinRange);
                        int intervalCalcMaxMin = (int)Settings.GetValueByName(AnalyzerSettingsEnum.MaxMinIntervals);
                        List<int> differenceMaxMin = new List<int>();
                        List<int> differenceMaxMinToLocationArr = new List<int>();
                        int location_index = 0;
                        for (int i = 0; i < (filteredValues.Count - periodCalcMaxMin); i+= intervalCalcMaxMin)
                        {
                            var rangeItems =(filteredValues.Skip(i).Take(periodCalcMaxMin).ToList());
                            int range = (int)(rangeItems.Max(t => t.Pressure) - rangeItems.Min(t => t.Pressure));
                            differenceMaxMin.Add(range);

                            differenceMaxMinToLocationArr.Add(++location_index);
                        }
                        FlowAverageAnalyzerResult averageResult = new FlowAverageAnalyzerResult();
                        averageResult.BackgroundMode = backgroundMode;
                        averageResult.AverageValue = filteredValues.Average(t => t.Pressure);
                        averageResult.Result = (averageResult.AverageValue <= Settings.GetValueByName(AnalyzerSettingsEnum.AvgMaxValue) && averageResult.AverageValue >= Settings.GetValueByName(AnalyzerSettingsEnum.AvgMinValue)) ? AnalyzerResultValue.Passed : AnalyzerResultValue.Failed;
                        results.Add(averageResult);

                        FlowAnalyzerResult result = new FlowAnalyzerResult(++flowtestNumber);
                        result.BackgroundMode = backgroundMode;
                        result.AverageValue = averageResult.AverageValue;
                        result.SetLocalErrors(differenceMaxMin, differenceMaxMinToLocationArr);
                        results.Add(result);
                    }
                    else//testing PBU
                    {
                        PrimingAnalyzerResult result = new PrimingAnalyzerResult();
                        result.BackgroundMode = backgroundMode;
                        int avgMinIndex = rangeTestValues.Select(x => x.Index).Min();
                        int avgMaxIndex = rangeTestValues.Select(x => x.Index).Max();
                        double totalsec = TimeSpan.FromMilliseconds((avgMaxIndex - avgMinIndex) * 100).TotalSeconds;
                        result.Time = totalsec.ToString() + $" sec (succeed for period < {AnalyzerSettingsEnum.FlowPBUPassFail})"; ;
                        result.Result = (totalsec < Settings.GetValueByName(AnalyzerSettingsEnum.FlowPBUPassFail)) ? AnalyzerResultValue.Passed : AnalyzerResultValue.Failed;
                        results.Add(result);
                    }
                }

                return results;
            });
        }

        public void GetPoints(List<DispenserSample> samples, IList<OxyPlot.DataPoint> points)
        {
            samples.ForEach(x =>
            {
                if (x.Pressure != 0.0)
                { points.Add(new OxyPlot.DataPoint(x.Index, x.Pressure)); }
            });
        }

        public class FlowAverageAnalyzerResult : AnalyzerResultBase
        {
            [Description("Average Value")]
            public double AverageValue { get; set; }
            public FlowAverageAnalyzerResult() : base()
            {
                AverageValue = 0.0;
                Result = AnalyzerResultValue.Undetermined;
            }
        }


        public class FlowAnalyzerResult : AnalyzerResultBase
        {
            #region Properties
            
            [Description("Max Error")]
            public string LocalErrors { get; set; }
            
            public double AverageValue { get; set; }

            public int TestNumber { get; set; }

            #endregion Properties

            public FlowAnalyzerResult(int testNumber) :base()
            {
                AverageValue = 0.0;
                Result = AnalyzerResultValue.Undetermined;
                TestNumber = testNumber;
            }

            /// <summary>
            /// Calculate result, max error. Set oxy plot column chart.
            /// </summary>
            /// <param name="differenceMaxMin">The difference maximum minimum.</param>
            public void SetLocalErrors(List<int> differenceMaxMin, List<int> differenceMaxMinToLocationArr)
            {
               // int count = differenceMaxMin.Where(x => x > 25 ).Count();
                int max_key = FindMaxErrorObject(differenceMaxMin);
                if (!BackgroundMode)
                {
                    var points = RangeToCountChart.Points;
                    points.Clear();
                    for (int i = 0; i <= max_key; i++)
                    {
                        int val = differenceMaxMin.Count(x => x == i);
                        if(val > 0 || points.Count > 0)
                        {
                            points.Add(new DataPoint(i, val));
                        }
                    }
                    this.IsShowPlotResult = true;
                    RangeToCountChart.Title = $"Local error histogram {TestNumber}";
                    RangeToCountChart.UpdateData();
                }
                var rangeToTimePoints = RangeToTimeChart.Points;
                rangeToTimePoints.Clear();
                for(int y = 0; y < differenceMaxMinToLocationArr.Count && y < differenceMaxMin.Count; y++)
                {
                     rangeToTimePoints.Add(new DataPoint(differenceMaxMinToLocationArr.ElementAt(y), differenceMaxMin.ElementAt(y)));
                }
                if (!BackgroundMode)
                {
                    RangeToTimeChart.Title = $"Local error vs position {TestNumber}";
                    RangeToTimeChart.UpdateData();
                }
                    
                string filename = FileHelper.GetFileToSaveFlowRangeToTimeData(TestNumber);
                if(filename.IsNotNullOrEmpty() && rangeToTimePoints.Count > 0)
                {
                    ExportnDataToExcel(rangeToTimePoints.ToList(), filename);
                }
            }

            private double BuildMeasurementError(List<int> range_values)
            {
                int count = range_values.Count();
                return  (count - (int)Settings.GetValueByName(AnalyzerSettingsEnum.TakeOffMaxMin));
            }

            /// <summary>
            /// Finds the maximum error object. Init LocalErrors message. Return max range value.
            /// </summary>
            private int FindMaxErrorObject(List<int> range_values)
            {
                var countValArr = range_values.GroupBy(x => x).Select(t => new { Key = t.Key, Value = t.Count() }).OrderBy(x=>x.Key).ToArray();
                double merror = Settings.GetValueByName(AnalyzerSettingsEnum.TakeOffMaxMin);// BuildMeasurementError(range_values);
                double sum = 0;
                int max_key = 0;
                int range = 0;
                for (int i = countValArr.Count() - 1; i >= 0; i--)
                {
                    sum += countValArr[i].Value;
                    if (max_key == 0)
                        max_key = (int)countValArr[i].Key;
                    if (sum > merror)
                    {
                        double persentageOfError = countValArr[i].Key / AverageValue * 100;
                        range = (int)countValArr[i].Key;
                        int occurrence = countValArr[i].Value;
                        LocalErrors = $" {persentageOfError.ToString("F2")}% where max local error = {range.ToString()} and occurrence = {occurrence.ToString()}";
                        break;
                    }
                }
                
                var res = range / AverageValue * 100;
                Result = res <= Settings.GetValueByName(AnalyzerSettingsEnum.MaxError) ? AnalyzerResultValue.Passed : AnalyzerResultValue.Failed;
                return max_key;
            }

            /// <summary>
            /// Exports the calibration data to excel.
            /// </summary>
            /// <param name="calibrationPoints">The calibration points.</param>
            /// <param name="fileName">Name of the file.</param>
            public static void ExportnDataToExcel(List<DataPoint> dataPoints, String fileName)
            {
                try
                {
                    CreateDataExcelTemplate(fileName);

                    using (ExcelWriter writer = new ExcelWriter(fileName))
                    {
                        writer.UpdateTableSize("RangeToTimeData", "A1:B" + (dataPoints.Count + 2).ToString());
                        writer.WriteData(dataPoints, "RangeToTimeData");
                    }
                }
                catch (Exception ex)
                {
                    Debug.WriteLine("Error: ", ex.Message);
                }
            }

            /// <summary>
            /// Creates the calibration data excel template.
            /// </summary>
            /// <param name="fileName">Name of the file.</param>
            public static void CreateDataExcelTemplate(String fileName)
            {
                var stream = EmbeddedResourceHelper.GetEmbeddedResourceStream("Tango.DispenserAnalyzer.UI.Models.FlowRangeToTimeResults.xlsx");

                using (FileStream fs = new FileStream(fileName, FileMode.Create))
                {
                    stream.Seek(0, SeekOrigin.Begin);
                    stream.CopyTo(fs);
                }
            }
        }
        
        public class MovingAverageFilter
        {
            public MovingAverageFilter()
            {
            }
            public void Filtering(List<DispenserSample> source)
            {
                int periodAverage = 5;
                for (int i = 0; i < (source.Count - 5); i++)
                {
                    source[i].Pressure = source.Skip(i).Take(periodAverage).Average(x => x.Pressure);
                }
            }
        }
    }
}