Beispiel #1
0
        /// <summary>
        /// Возвращает самое длинное задание с заданным материалом.
        /// </summary>
        /// <param name="MaterialId"></param>
        /// <param name="Products"></param>
        /// <param name="Device"></param>
        /// <returns></returns>
        public int GetBiggerTask(int MaterialId, MaterialList Materials, ProductionList Products, BaseDeviceType Device)
        {
            int TaskIndex = -1;
            double TaskTime = 0;
            for (int i = 0, i_end = this.Count; i < i_end; i++)
            {
                if (this[i].MaterialId == MaterialId)
                {
                    if (TaskIndex == -1)
                    {
                        TaskIndex = i;
                        TaskTime = (Device == BaseDeviceType.Saw ?
                            this[i].SawingTime(Materials, Products)
                            : this[i].PolishingTime(Materials, Products));
                    }
                    else
                    {
                        double NewTime = (Device == BaseDeviceType.Saw ?
                            this[i].SawingTime(Materials, Products)
                            : this[i].PolishingTime(Materials, Products));
                        if (NewTime > TaskTime)
                        {
                            TaskIndex = i;
                            TaskTime = NewTime;
                        }
                    }
                }
            }

            return TaskIndex != -1 ? this[TaskIndex].Id : -1;
        }
 public new object Clone()
 {
     MaterialList NewList = new MaterialList();
     foreach (MaterialItem item in items)
     {
         NewList.Add((MaterialItem)item.Clone());
     }
     return NewList;
 }
Beispiel #3
0
        /// <summary>
        /// Возвращает время распиливания для задания.
        /// </summary>
        /// <param name="Materials">Список исходных материалов.</param>
        /// <param name="Productions">Список исходной продукции.</param>
        /// <returns>Полное время распиливания для заказа.</returns>
        public double SawingTime(MaterialList Materials, ProductionList Productions)
        {
            int MaterialIndex = Materials.GetIndexById(materialId);
            if (MaterialIndex == -1)
                return MaterialIndex;

            int ProductionIndex = Productions.GetIndexById(productionId);
            if (ProductionIndex == -1)
                return ProductionIndex;

            int IndexOfSizeMas = Productions[ProductionIndex].SupSizes.IndexOf(sizeIndex);
            if (IndexOfSizeMas == -1)
                return IndexOfSizeMas;

            // определяем площадь элемента задания
            double S = Productions[ProductionIndex].SupSizes[IndexOfSizeMas].Length * Productions[ProductionIndex].SupSizes[IndexOfSizeMas].Width / 1e+6;

            return (S * Materials[MaterialIndex].SawingTime + 0.5); // 0,5 - для правильного округления до целых
        }
Beispiel #4
0
 /// <summary>
 /// Возвращает суммарную длительность заданий,
 /// состоящих из одного материала
 /// </summary>
 /// <param name="MaterialId"></param>
 /// <param name="Products"></param>
 /// <param name="Device"></param>
 /// <returns></returns>
 public double TaskDurationByMaterial(int MaterialId, MaterialList Materials, ProductionList Products, BaseDeviceType Device)
 {
     double Result = 0;
     for (int i = 0, i_end = this.Count; i < i_end; i++)
     {
         if (this[i].MaterialId == MaterialId)
         {
             Result += Device == BaseDeviceType.Saw ?
                 this[i].SawingTime(Materials, Products) :
                 this[i].PolishingTime(Materials, Products);
         }
     }
     return Result;
 }
Beispiel #5
0
 /// <summary>
 /// Возвращает сумму времени выполнения всех заданий, которые нужно выполнить до определенного срока
 /// </summary>
 /// <param name="DeadLine">Срок, до которого должно исполниться задание.</param>
 /// <param name="Materials">Список материалов.</param>
 /// <param name="Productions">Список продукции.</param>
 /// <returns></returns>
 public double GetTaskDurationByDeadLine(DateTime DeadLine, MaterialList Materials, ProductionList Productions)
 {
     double Result = 0;
     foreach (TaskItem item in items)
     {
         if (item.UseDeadLine)
         {
             if (item.DeadLine <= DeadLine)
             {
                 Result += item.SawingTime(Materials, Productions) + item.PolishingTime(Materials, Productions);
             }
         }
     }
     return Result;
 }
        /// <summary>
        /// Возвращает идентификатор наиболее важного задания.
        /// Важность зависит от времени выполнения.
        /// Чем дольше задание выполняется, тем оно важнее.
        /// </summary>
        /// <param name="DefaultList"></param>
        /// <param name="MaterialID"></param>
        /// <returns></returns>
        private int MostImportantTask(TaskList Tasks, MaterialList Materials, 
            ProductionList Productions, int MaterialID, BaseDeviceType DeviceType)
        {
            int ResultId = -1;
            if (Tasks.Count == 0)
                return ResultId;

            // находим индекс первого задания данного типа
            int ResultIndex = -1;
            for (int i = 0; i < Tasks.Count; i++)
            {
                if (Tasks[i].MaterialId == MaterialID)
                {
                    ResultIndex = i;
                    break;
                }
            }

            // если заданий под нужный материал вовсе нет, то до свидания
            if (ResultIndex == -1)
                return ResultId;

            ResultId = Tasks[ResultIndex].Id;

            for (int i = ResultIndex + 1; i < Tasks.Count; i++)
            {
                if (Tasks[i].MaterialId != MaterialID)
                    continue;

                if ((DeviceType == BaseDeviceType.Saw ? Tasks[i].SawingTime(Materials, Productions) : Tasks[i].PolishingTime(Materials, Productions)) >
                    (DeviceType == BaseDeviceType.Saw ? Tasks[ResultIndex].SawingTime(Materials, Productions) : Tasks[ResultIndex].PolishingTime(Materials, Productions)))
                {
                    ResultId = Tasks[i].Id;
                    ResultIndex = i;
                }
            }
            return ResultId;
        }
        /// <summary>
        /// Метод возвращает идентификатор материала которого больше всего
        /// по времени обработки на пиле.
        /// </summary>
        /// <param name="DefaultSawingList"></param>
        private int MostImportantMaterial(TaskList Tasks, MaterialList Materials, 
            ProductionList Productions, BaseDeviceType DeviceType)
        {
            // список в котором хранится материал и суммарное время всех заданий
            // под данный материал
            List<MaterialPair> material = new List<MaterialPair>();

            // перебираем задания и наполняем список времен
            for (int i = 0; i < Tasks.Count; i++)
            {
                int CurrentMaterialID = Tasks[i].MaterialId;
                int FindedMaterialIndex = -1;
                for (int j = 0; j < material.Count; j++)
                {
                    if (material[j].ID == CurrentMaterialID)
                    {
                        FindedMaterialIndex = j;
                        break;
                    }
                }

                // если материал уже есть в списке
                if (FindedMaterialIndex > -1)
                    material[FindedMaterialIndex].Time += DeviceType == BaseDeviceType.Saw ?
                        Tasks[i].SawingTime(Materials, Productions) : Tasks[i].PolishingTime(Materials, Productions);
                else // если материала нет в списке
                    material.Add(new MaterialPair(CurrentMaterialID,
                       DeviceType == BaseDeviceType.Saw ? Tasks[i].SawingTime(Materials, Productions) :
                       Tasks[i].PolishingTime(Materials, Productions)));

            }

            // перебираем задания и наполняем список времен
            int Result = -1;
            double CurrentMaxTime = 0;
            for (int i = 0; i < material.Count; i++)
            {
                if (material[i].Time > CurrentMaxTime)
                {
                    CurrentMaxTime = material[i].Time;
                    Result = i;
                }
            }

            return Result != -1 ? material[Result].ID : -1;
        }
 /// <summary>
 /// Возвращает среднее арифметическое время настройки всех устройств на заданный список материалов
 /// </summary>
 /// <param name="Materials"></param>
 /// <returns></returns>
 public double GetMidConfigTime(MaterialList Materials)
 {
     double SumTime = 0;
     for (int i = 0; i < Materials.Count; i++)
     {
         SumTime += GetMidConfigTime(Materials[i].Id);
     }
     return Materials.Count != 0 ? SumTime / Materials.Count : 0;
 }
 public void Assign(Configuration Obj)
 {
     baseTime = Obj.baseTime;
     materials = (MaterialList)Obj.materials.Clone();
     saws = (DeviceList)Obj.saws.Clone();
     grinders = (DeviceList)Obj.grinders.Clone();
     productions = (ProductionList)Obj.productions.Clone();
     customers = (CustomerList)Obj.customers.Clone();
     orders = (OrderList)Obj.orders.Clone();
     tasks = (TaskList)Obj.tasks.Clone();
 }