コード例 #1
0
ファイル: Reporting.cs プロジェクト: ResidentTGT/Scheduler
        private List <DetailsBatchBlock> GenerateDetailsBatchBlocks(ProductionItemQuantumsGroup productionItemQuantumsGroup, int workshopId, TimeSpan startTime)
        {
            var detailsBatchBlocks = new List <DetailsBatchBlock>();

            var items = productionItemQuantumsGroup.ProductionItemQuantums;

            for (int i = 0; i < items.Count; i++)
            {
                // var equipmentsInWorkshop = _dbManager.GetEquipmentsInWorkshop(workshopId).Select(e => e.Id);
                for (int j = 0; j < items[i].MachiningDurations.Count; j++)
                {
                    detailsBatchBlocks.Add(new DetailsBatchBlock()
                    {
                        DetailId     = items[i].Detail.Id,
                        DetailName   = items[i].Detail.Title,
                        DetailsCount = items[i].Count,
                        Duration     = items[i].MachiningDurations[j].Ticks,
                        EquipmentId  = items[i].Detail.EquipmentsIdSequence[j],
                        StartTime    = items[i].StartTimes[j].Ticks + startTime.Ticks
                    });
                }
            }

            return(detailsBatchBlocks);
        }
コード例 #2
0
        private void SortByLowestTime(DetailsTiming detailsTiming, ProductionItemQuantumsGroup productionItemQuantumsGroup, Dictionary <string, TimeSpan> dictDecisiveRulesTimes, int itemsCountInOnePart)
        {
            var rule = dictDecisiveRulesTimes.OrderBy(d => d.Value).First().Key;

            Logger.Log($"Правило с наименьшим временем: {rule}", LogLevel.Trace);

            Logger.Log($"Сортировка деталей по правилу {rule} начата.", LogLevel.Trace);
            switch (rule)
            {
            case "LUKR":
                Lukr.SortDetails(productionItemQuantumsGroup);
                break;

            case "SPT":
                Spt.SortDetails(productionItemQuantumsGroup);
                break;

            case "LPT":
                Lpt.SortDetails(productionItemQuantumsGroup);
                break;

            case "ReverseLukr":
                Lukr.SortDetails(productionItemQuantumsGroup);
                break;

            default:
                break;
            }
            Logger.Log($"Сортировка деталей по правилу {rule} закончена.", LogLevel.Trace);

            Logger.Log($"Определение суммарного времени обработки группы по лучшему правилу {rule} начато.", LogLevel.Trace);
            var time = detailsTiming.CountGroupMachiningTime(productionItemQuantumsGroup, true, itemsCountInOnePart);

            Logger.Log($"Определение суммарного времени обработки группы по лучшему правилу {rule} закончено. Получившееся время: {time}", LogLevel.Trace);
        }
コード例 #3
0
 private void CountTimesForGroup(ProductionItemQuantumsGroup group)
 {
     for (var j = 0; j < group.WorkshopSequence.Count; j++)
     {
         if (j == 0)
         {
             group.WorkshopStartTimes.Add(new TimeSpan(0));
             group.WorkshopEndTimes.Add(group.WorkshopDurations[j]);
         }
         else
         {
             group.WorkshopStartTimes.Add(group.WorkshopEndTimes[j - 1] + group.TransportOperations[j - 1].Duration);
             group.WorkshopEndTimes.Add(group.WorkshopStartTimes[j] + group.WorkshopDurations[j]);
         }
     }
 }
コード例 #4
0
ファイル: ReverseLukr.cs プロジェクト: ResidentTGT/Scheduler
 internal static void SortDetails(ProductionItemQuantumsGroup productionItemQuantumsGroup)
 {
     productionItemQuantumsGroup.ProductionItemQuantums = productionItemQuantumsGroup.ProductionItemQuantums.OrderByDescending(r => SumDurations(r.Detail)).ToList();
 }
コード例 #5
0
 internal static void SortDetails(ProductionItemQuantumsGroup productionItemQuantumsGroup)
 {
     productionItemQuantumsGroup.ProductionItemQuantums = productionItemQuantumsGroup.ProductionItemQuantums
                                                          .OrderBy(r => r.Detail.Operations.First(o => o.Equipment.Workshop != null).MainTime).ToList();
 }
コード例 #6
0
        public TimeSpan CountGroupMachiningTime(ProductionItemQuantumsGroup productionItemQuantumsGroup, bool isFinally, int itemsCountInOnePart)
        {
            var productionItemQuantums = productionItemQuantumsGroup.ProductionItemQuantums;

            var previousGroupLastTime = new TimeSpan(0);

            for (var i = 0; i < productionItemQuantumsGroup.WorkshopSequence.Count; i++)
            {
                var currentWorkshopGroupDurationTime = new TimeSpan(0);

                Logger.Log($"Начат расчет времени группы деталей для цеха с id '{productionItemQuantumsGroup.WorkshopSequence[i]}'", LogLevel.Info);
                for (var j = 0; j < productionItemQuantums.Count; j++)
                {
                    var startTimes = new List <TimeSpan>();
                    var endTimes   = new List <TimeSpan>();
                    var durations  = new List <TimeSpan>();

                    var operationsInWorkshop = _groupingDetails.GetSortedByRouteOperationsByWorkshopId(productionItemQuantums[j], productionItemQuantumsGroup.WorkshopSequence[i]);

                    var countOfDetailsInOneGroup = productionItemQuantums[j].Count * itemsCountInOnePart;
                    CountTimesForOperationsInWorkshop(operationsInWorkshop, countOfDetailsInOneGroup, startTimes, endTimes, durations);

                    if (j != 0)
                    {
                        ShiftTime(productionItemQuantums, operationsInWorkshop, productionItemQuantumsGroup.WorkshopSequence[i], j, startTimes, endTimes);
                    }


                    var diffBetween = previousGroupLastTime.Ticks - startTimes.Min().Ticks;


                    if (diffBetween > 0)
                    {
                        for (var k = 0; k < startTimes.Count; k++)
                        {
                            startTimes[k] += new TimeSpan(diffBetween);
                            endTimes[k]   += new TimeSpan(diffBetween);
                        }
                    }

                    foreach (var dur in durations)
                    {
                        productionItemQuantums[j].MachiningDurations.Add(dur);
                    }
                    foreach (var startTime in startTimes)
                    {
                        productionItemQuantums[j].StartTimes.Add(startTime);
                    }
                    foreach (var endTime in endTimes)
                    {
                        productionItemQuantums[j].EndTimes.Add(endTime);
                    }

                    if (endTimes.Max().Ticks - previousGroupLastTime.Ticks > currentWorkshopGroupDurationTime.Ticks)
                    {
                        currentWorkshopGroupDurationTime = new TimeSpan(endTimes.Max().Ticks - previousGroupLastTime.Ticks);
                    }

                    if (productionItemQuantums.Count == (j + 1))
                    {
                        long max = 0;
                        foreach (var iq in productionItemQuantums)
                        {
                            if (max < iq.EndTimes.Max().Ticks)
                            {
                                max = iq.EndTimes.Max().Ticks;
                            }
                        }

                        previousGroupLastTime = new TimeSpan(max);
                        if (isFinally)
                        {
                            productionItemQuantumsGroup.WorkshopDurations.Add(currentWorkshopGroupDurationTime);
                        }
                    }
                }

                Logger.Log($"Закончен расчет времени группы деталей для цеха с id '{productionItemQuantumsGroup.WorkshopSequence[i]}', " +
                           $"суммарное время группы: {currentWorkshopGroupDurationTime}", LogLevel.Info);
            }

            if (!isFinally)
            {
                foreach (var d in productionItemQuantums)
                {
                    d.EndTimes.Clear();
                    d.StartTimes.Clear();
                    d.MachiningDurations.Clear();
                }
            }

            return(previousGroupLastTime);
        }
コード例 #7
0
        internal ProductionItemQuantumsGroupDto ConvertProductionItemQuantumsGroupForViewing(ProductionItemQuantumsGroup productionItemQuantumsGroup)
        {
            var productionItemQuantumsGroupDto = new ProductionItemQuantumsGroupDto()
            {
                ProductionItemQuantums = productionItemQuantumsGroup.ProductionItemQuantums.Select(p => ConvertProductionItemQuantumForViewing(p)).ToList(),
                WorkshopDurations      = productionItemQuantumsGroup.WorkshopDurations.Select(a => a.Ticks).ToList(),
                WorkshopEndTimes       = productionItemQuantumsGroup.WorkshopEndTimes.Select(a => a.Ticks).ToList(),
                WorkshopSequence       = productionItemQuantumsGroup.WorkshopSequence,
                WorkshopStartTimes     = productionItemQuantumsGroup.WorkshopStartTimes.Select(a => a.Ticks).ToList()
            };

            return(productionItemQuantumsGroupDto);
        }