策略最小化换线

src/main/java/com/aps/entity/Algorithm/OrderSortRule.java

@@ -7,6 +7,7 @@ import java.util.List;
 public class OrderSortRule {
     private boolean enabled;
     private List<SortCondition> conditions;
+    //private boolean minimizeChangeover=false;
     
     @Data
     public static class SortCondition {

src/main/java/com/aps/entity/basic/Order.java

@@ -176,4 +176,11 @@ public class Order {
      * 物料需求
      */
     private List<OrderMaterialRequirement> materialRequirementList;
+
+    /**
+     * 换线成本
+     */
+    private double changeoverCost;
+
+    private int changeoverPriority;
 }
\ No newline at end of file

src/main/java/com/aps/service/Algorithm/GeneticDecoder.java

@@ -489,19 +489,19 @@ if(finishedOrder==null||finishedOrder.size()==0)
         }
 
         int setupTime=0;
-        CopyOnWriteArrayList<GAScheduleResult> machineTasks=null;
-        CopyOnWriteArrayList<GAScheduleResult> machineTasks1 =chromosome.getResult().stream()
+
+        CopyOnWriteArrayList<GAScheduleResult> machineTasks =chromosome.getResult().stream()
                 .filter(t -> t.getMachineId() == machine.getId())
                 .sorted(Comparator.comparingInt(GAScheduleResult::getStartTime))
                 .collect(Collectors.toCollection(CopyOnWriteArrayList::new));
 
 
      GAScheduleResult lastGeneOnMachine = null;
-     if(machineTasks1!=null&&machineTasks1.size()>0)
+     if(machineTasks!=null&&machineTasks.size()>0)
      {
-         lastGeneOnMachine=machineTasks1.get(machineTasks1.size()-1);
+         lastGeneOnMachine=machineTasks.get(machineTasks.size()-1);
      }
-        if(lastGeneOnMachine!=null)
+        if(lastGeneOnMachine!=null&&_globalParam.is_smoothChangeOver())
         {
             earliestStartTime = Math.max(earliestStartTime,lastGeneOnMachine.getEndTime());
         }
@@ -543,16 +543,16 @@ if(finishedOrder==null||finishedOrder.size()==0)
         }
 
 
-        machineTasks1 =chromosome.getResult().stream()
+        machineTasks =chromosome.getResult().stream()
                 .filter(t -> t.getMachineId() == machine.getId())
                 .sorted(Comparator.comparingInt(GAScheduleResult::getStartTime))
                 .collect(Collectors.toCollection(CopyOnWriteArrayList::new));
 
 
 
-        if(machineTasks1!=null&&machineTasks1.size()>0)
+        if(machineTasks!=null&&machineTasks.size()>0&&_globalParam.is_smoothChangeOver())
         {
-            lastGeneOnMachine=machineTasks1.get(machineTasks1.size()-1);
+            lastGeneOnMachine=machineTasks.get(machineTasks.size()-1);
         }
 
         if (_globalParam.is_smoothChangeOver()) {

src/main/java/com/aps/service/Algorithm/MaterialRequirementService.java

@@ -1617,6 +1617,9 @@ if(headers1==null)
         redisUtils.del(sceneId+routingDiscreteParamCacheKey);
         GlobalCacheUtil.remove(sceneId+routingDiscreteParamCacheKey);
 
+        redisUtils.del(sceneId+materialsCacheKey);
+        GlobalCacheUtil.remove(sceneId+materialsCacheKey);
+
 
 
     }

src/main/java/com/aps/service/plan/PlanResultService.java

@@ -1166,6 +1166,16 @@ private  GlobalParam InitGlobalParam()
                             conditions.add(condition);
                             files.add("orderCode");
                             i++;
+                        }else if (strategy.getName().equals("minimize_tool_changeovers")) {
+                            // 最小化换线策略需要特殊处理，这里只做标记
+                            // 实际排序逻辑将在orderSortService中处理
+                            OrderSortRule.SortCondition condition = new OrderSortRule.SortCondition();
+                            condition.setSequence(i);
+                            condition.setFieldName("minimize_changeover");
+                            condition.setReverse(false);
+                            conditions.add(condition);
+                            files.add("minimize_changeover");
+                            i++;
                         }
 
                     }

src/test/java/com/aps/demo/OrderSortServiceTest.java

@@ -13,9 +13,7 @@ import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.OffsetDateTime;
 import java.time.format.DateTimeFormatter;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.List;
+import java.util.*;
 import java.util.stream.Collectors;
 
 /**
@@ -45,18 +43,70 @@ class OrderSortServiceTest {
         // 创建多条件排序规则：先按dueDate，再按priority
         OrderSortRule rule = createMultiConditionRule();
 
+        List<Order> orders=new ArrayList<>();
+        Order order=new Order();
+        order.setId(1);
+        order.setOrderId("001");
+        order.setRoutingId(1);
+        order.setMaterialCode("M001");
+        order.setSerie("S001");
+        orders.add(order);
+
 
 
+
+        Order order2=new Order();
+        order2.setId(2);
+        order2.setOrderId("002");
+        order2.setRoutingId(1);
+        order2.setMaterialCode("M002");
+        order2.setSerie("S001");
+        orders.add(order2);
+
+        Order order3=new Order();
+        order3.setId(3);
+        order3.setOrderId("003");
+        order3.setRoutingId(1);
+        order3.setMaterialCode("M002");
+        order3.setSerie("S001");
+        orders.add(order3);
+
+        Order order4=new Order();
+        order4.setId(4);
+        order4.setOrderId("004");
+        order4.setRoutingId(2);
+        order4.setMaterialCode("M001");
+        order4.setSerie("S002");
+        orders.add(order4);
+
+        Order order5=new Order();
+        order5.setId(5);
+        order5.setOrderId("005");
+        order5.setRoutingId(2);
+        order5.setMaterialCode("M002");
+        order5.setSerie("S003");
+        orders.add(order5);
+
+        Order order6=new Order();
+        order6.setId(6);
+        order6.setOrderId("005");
+        order6.setRoutingId(2);
+        order6.setMaterialCode("M002");
+        order6.setSerie("S003");
+        orders.add(order6);
         // 执行测试
-        orderSortService.assignPriority(testOrders, rule);
+
+
+
+        orderSortService.assignPriorityValues(orders, rule);
 
         // 按照优先级排序
-        testOrders.sort(
+        orders.sort(
                 Comparator.comparing(Order::getActualPriority).reversed()
         );
         
         // 验证多级优先级分配
-        printOrderPriorities(testOrders); // 调试输出
+        printOrderPriorities(orders); // 调试输出
 
     }
 
@@ -102,17 +152,18 @@ class OrderSortServiceTest {
         // 条件2：按到期日
         OrderSortRule.SortCondition condition2 = new OrderSortRule.SortCondition();
         condition2.setSequence(2);
-        condition2.setFieldName("dueDate");
+        condition2.setFieldName("minimize_changeover");
         condition2.setReverse(false); // 早到期在前
         conditions.add(condition2);
         
         // 条件3：按优先级
         OrderSortRule.SortCondition condition3 = new OrderSortRule.SortCondition();
         condition3.setSequence(3);
-        condition3.setFieldName("priority");
+        condition3.setFieldName("materialCode");
         condition3.setReverse(true); // 高优先级在前
         conditions.add(condition3);
 
+
         rule.setConditions(conditions);
         return rule;
     }

src/test/java/com/aps/demo/PlanResultServiceTest.java

@@ -42,7 +42,7 @@ public class PlanResultServiceTest {
      // planResultService.execute2("5475E00B844847ACB6DC20227967BA2F");
       //  planResultService.execute2("00E0C5D3E4AD4F36B56C39395906618D");
 
-         planResultService.execute2("31F0FF4DFAD844BD9C72EDEEF3430A1F");
+         planResultService.execute2("D6836ADCEF5F4537A4BDD896ECC2EC6A");
     //   planResultService.execute2("265F24B6DF3C40E4B17D193B0CC8AAF2");
 //        LocalDateTime t=   LocalDateTime.of(2026, 02, 14, 1, 25, 52);
  //      List<Integer> opids=new ArrayList<>();//BCA6FA43FFA444D3952CF8F6E1EA291B