public LotStepOvertakingDistribution(List <OvertakingRecord> records, OvertakingDistributionParameters parameters, List <LotStep> lotSteps) : base(records)
        {
            this.records    = records;
            this.parameters = parameters;
            this.lotSteps   = lotSteps;

            distributions = new Dictionary <string, OvertakingDistribution>();

            buildDistribution();
        }
        public OvertakingDistribution(List <OvertakingRecord> records, OvertakingDistributionParameters parameters) : base(records)
        {
            this.records    = records.OrderBy(x => x.WIPIn).ToList();
            this.parameters = parameters;
            LB = records.Select(x => x.WIPIn).Min();
            UB = records.Select(x => x.WIPIn).Max();

            distributions = new Dictionary <int, EmpericalDistribution>();
            WIPMapping    = new Dictionary <int, int>();

            buildDistributions();
            buildWIPMapping();

            //writeToConsole();
        }
        public Dictionary <string, OvertakingDistributionBase> GetOvertakingDistributions(bool isLotStepOvertaking = true)
        {
            Dictionary <string, OvertakingDistributionBase> distributions = new Dictionary <string, OvertakingDistributionBase>();

            // Read all overtaking records
            List <OvertakingRecord> records = new List <OvertakingRecord>();

            using (StreamReader reader = new StreamReader(Path.Combine(directory, "OvertakingRecords.csv")))
            {
                string headerline = reader.ReadLine();

                while (!reader.EndOfStream)
                {
                    string dataline = reader.ReadLine();

                    OvertakingRecord rec = new OvertakingRecord();

                    string[] headers = headerline.Trim(',').Split(',');
                    string[] data    = dataline.Trim(',').Split(',');

                    for (int i = 0; i < data.Length; i++)
                    {
                        if (headers[i] == "WorkStation")
                        {
                            rec.WorkCenter = data[i];
                        }
                        else if (headers[i] == "IRDGroup")
                        {
                            rec.LotStep = data[i];
                        }
                        else if (headers[i] == "WIPIn")
                        {
                            rec.WIPIn = Convert.ToInt32(data[i]);
                        }
                        else if (headers[i] == "OvertakenLots")
                        {
                            rec.OvertakenLots = Convert.ToInt32(data[i]);
                        }
                        else
                        {
                            throw new Exception($"{headers[i]} is unknown");
                        }
                    }

                    records.Add(rec);
                }
            }

            // Read overtaking distribution parameters
            OvertakingDistributionParameters parameters = new OvertakingDistributionParameters(10, 100, 1);

            // Select records per workcenter per lotstep
            foreach (string wc in workcenters)
            {
                List <OvertakingRecord> recordsWC = records.Where(x => x.WorkCenter == wc).ToList();

                if (isLotStepOvertaking)
                {
                    distributions.Add(wc, new LotStepOvertakingDistribution(recordsWC, parameters, lotStepsPerWorkStation[wc]));
                }
                else
                {
                    distributions.Add(wc, new OvertakingDistribution(recordsWC, parameters));
                }
            }

            return(distributions);
        }