示例#1
0
        private void JobShopScheduling(OrderOperationGraph orderOperationGraph)
        {
            IDbTransactionData dbTransactionData =
                ZppConfiguration.CacheManager.GetDbTransactionData();
            IAggregator aggregator = ZppConfiguration.CacheManager.GetAggregator();

            // some validations
            if (dbTransactionData.ProductionOrderGetAll().Any() == false)
            {
                // no JobShopScheduling needed, all Demands were satisfied without the need for a productionOrder
                return;
            }

            foreach (var productionOrder in dbTransactionData.ProductionOrderGetAll())
            {
                List <ProductionOrderOperation> operations =
                    aggregator.GetProductionOrderOperationsOfProductionOrder(
                        (ProductionOrder)productionOrder);
                if (operations == null || operations.Any() == false)
                {
                    throw new MrpRunException(
                              "How could it happen, that a productionOrder without operations exists ?");
                }
            }

            // start !
            IDirectedGraph <INode> operationGraph =
                new OperationGraph(orderOperationGraph);

            _jobShopScheduler.ScheduleWithGifflerThompsonAsZaepfel(
                new PriorityRule(operationGraph), operationGraph);
        }
        private static void HandleProductionOrderIsInStateCreated(ProductionOrder productionOrder,
                                                                  IAggregator aggregator, IDbTransactionData dbTransactionData)
        {
            // delete all operations
            List <ProductionOrderOperation> operations =
                aggregator.GetProductionOrderOperationsOfProductionOrder(productionOrder);

            dbTransactionData.ProductionOrderOperationDeleteAll(operations);

            // collect entities and demandToProviders/providerToDemands to delete
            List <IDemandOrProvider> demandOrProvidersToDelete =
                CreateProductionOrderSubGraph(true, productionOrder, aggregator);

            // delete all collected entities
            IOpenDemandManager openDemandManager =
                ZppConfiguration.CacheManager.GetOpenDemandManager();

            foreach (var demandOrProvider in demandOrProvidersToDelete)
            {
                // don't forget to delete it from openDemands
                if (demandOrProvider.GetType() == typeof(StockExchangeDemand))
                {
                    if (openDemandManager.Contains((Demand)demandOrProvider))
                    {
                        openDemandManager.RemoveDemand((Demand)demandOrProvider);
                    }
                }

                List <ILinkDemandAndProvider> demandAndProviderLinks =
                    aggregator.GetArrowsToAndFrom(demandOrProvider);
                dbTransactionData.DeleteAllFrom(demandAndProviderLinks);

                dbTransactionData.DeleteA(demandOrProvider);
            }
        }
        private static void ArchiveOperations(IDbTransactionData dbTransactionData,
                                              IDbTransactionData dbTransactionDataArchive, IAggregator aggregator,
                                              ProductionOrder productionOrder)
        {
            List <ProductionOrderOperation> operations =
                aggregator.GetProductionOrderOperationsOfProductionOrder(productionOrder);

            dbTransactionDataArchive.ProductionOrderOperationAddAll(operations);
            dbTransactionData.ProductionOrderOperationDeleteAll(operations);
        }
示例#4
0
        private Priority GetPriorityOfProductionOrderOperation(DueTime now,
                                                               ProductionOrderOperation givenProductionOrderOperation,
                                                               DueTime minStartNextOfParentProvider)
        {
            IAggregator aggregator = ZppConfiguration.CacheManager.GetAggregator();

            Dictionary <HierarchyNumber, DueTime> alreadySummedHierarchyNumbers =
                new Dictionary <HierarchyNumber, DueTime>();
            DueTime sumDurationsOfOperations = DueTime.Zero();
            // O(1)
            List <ProductionOrderOperation> productionOrderOperations =
                aggregator.GetProductionOrderOperationsOfProductionOrder(givenProductionOrderOperation
                                                                         .GetProductionOrderId());

            foreach (var productionOrderOperation in productionOrderOperations)
            {
                // only later operations, which have a smaller hierarchyNumber, have to be considered
                if (productionOrderOperation.GetHierarchyNumber()
                    .IsSmallerThan(givenProductionOrderOperation.GetHierarchyNumber()))
                {
                    continue;
                }

                if (alreadySummedHierarchyNumbers.ContainsKey(productionOrderOperation
                                                              .GetHierarchyNumber()))
                {
                    DueTime alreadySummedHierarchyNumber =
                        alreadySummedHierarchyNumbers[
                            productionOrderOperation.GetHierarchyNumber()];
                    if (productionOrderOperation.GetDuration().ToDueTime()
                        .IsGreaterThan(alreadySummedHierarchyNumber))
                    {
                        sumDurationsOfOperations.IncrementBy(productionOrderOperation.GetDuration()
                                                             .ToDueTime().Minus(alreadySummedHierarchyNumber));
                    }
                }
                else
                {
                    alreadySummedHierarchyNumbers.Add(productionOrderOperation.GetHierarchyNumber(),
                                                      productionOrderOperation.GetDuration().ToDueTime());
                }
            }

            return(new Priority(minStartNextOfParentProvider.Minus(now)
                                .Minus(sumDurationsOfOperations).GetValue()));
        }
示例#5
0
        /**
         * determines state from all operations
         */
        public State DetermineProductionOrderState()
        {
            IAggregator aggregator                 = ZppConfiguration.CacheManager.GetAggregator();
            bool        atLeastOneIsInProgress     = false;
            bool        atLeastOneIsFinished       = false;
            bool        atLeastOneIsInStateCreated = false;
            var         productionOrderOperations  =
                aggregator.GetProductionOrderOperationsOfProductionOrder(this);

            foreach (var productionOrderOperation in productionOrderOperations)
            {
                if (productionOrderOperation.IsInProgress())
                {
                    atLeastOneIsInProgress = true;
                    break;
                }
                else if (productionOrderOperation.IsFinished())
                {
                    atLeastOneIsFinished = true;
                }
                else
                {
                    atLeastOneIsInStateCreated = true;
                }
            }

            if (atLeastOneIsInProgress || atLeastOneIsInStateCreated && atLeastOneIsFinished)
            {
                return(State.InProgress);
            }
            else if (atLeastOneIsInStateCreated && !atLeastOneIsInProgress && !atLeastOneIsFinished)
            {
                return(State.Created);
            }
            else if (atLeastOneIsFinished && !atLeastOneIsInProgress && !atLeastOneIsInStateCreated)
            {
                return(State.Finished);
            }
            else
            {
                throw new MrpRunException("This state is not expected.");
            }
        }