Merge remote-tracking branch 'origin/tl'

# Conflicts:
#	src/main/java/com/aps/entity/basic/Order.java
#	src/main/java/com/aps/service/impl/LanuchServiceImpl.java

src/main/java/com/aps/controller/gantt/ResourceGanttController.java

@@ -117,25 +117,9 @@ public class ResourceGanttController {
 
     }
 
-    @GetMapping("/getScene")
-    @Operation(summary = "获取所有场景ID", description = "获取所有场景ID")
-    public Chromosome getScene() {
-        // 调用 PlanResultService 获取 ScheduleChromosome 列表
-        Chromosome scheduleChromosomes = planResultService.execute1();
 
-        // 提取所有场景ID
-        return scheduleChromosomes;
-    }
 
-    @GetMapping("/getScene2")
-    @Operation(summary = "获取所有场景ID", description = "获取所有场景ID")
-    public Chromosome getScene2() {
-        // 调用 PlanResultService 获取 ScheduleChromosome 列表
-        Chromosome scheduleChromosomes = planResultService.execute2("B571EF6682DB463AB2977B1055A74112");
 
-        // 提取所有场景ID
-        return scheduleChromosomes;
-    }
 
     @GetMapping("/SyncMaterials")
     @Operation(summary = "更新物料信息缓存", description = "更新物料信息缓存")

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

@@ -18,11 +18,10 @@ public class BOMBuildResult {
 
     private List<Machine> newMachines;
 
-    public BOMBuildResult(List<OrderMaterialRequirement> materialRequirements, List<Order> childOrders,List<Entry> newentrys,List<Machine> newMachines) {
+    public BOMBuildResult(List<OrderMaterialRequirement> materialRequirements, List<Order> childOrders,List<Entry> newentrys) {
         this.materialRequirements = materialRequirements;
         this.childOrders = childOrders;
         this.newentrys=newentrys;
-        this.newMachines=newMachines;
     }
 
     public List<OrderMaterialRequirement> getMaterialRequirements() {

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

@@ -3,15 +3,14 @@ package com.aps.entity.Algorithm;
 import com.aps.entity.Algorithm.IDAndChildID.GroupResult;
 import com.aps.entity.basic.Entry;
 import com.aps.entity.basic.Machine;
+import com.aps.entity.basic.Material;
 import com.aps.entity.basic.Order;
 import lombok.Data;
 
 
 
 import java.time.LocalDateTime;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.UUID;
+import java.util.*;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.stream.Collectors;
 
@@ -24,6 +23,8 @@ public class Chromosome {
 
     private String ID = UUID.randomUUID().toString();
 
+
+
     private Integer version=0;
 
     /// <summary>
@@ -41,28 +42,44 @@ public class Chromosome {
     /// </summary>
     private String geneStr;
 
-    public void  setMachineSelection(List<Integer> val) {
-        machineSelection = val;
-        machineStr = machineSelection.stream()
-                .map(String::valueOf) // 将每个 Integer 转换为 String
+    public String  getGeneStr() {
+        geneStr=getMachineStr()+"_"+getOperationStr();
+        return  geneStr;
+    }
+
+    private Integer gsOrls=0;
+
+
+    public String  getMachineStr() {
+
+        machineStr=   Optional.ofNullable(machineSelection)
+                .orElse(Collections.emptyList())
+                .stream()
+                .map(String::valueOf) // Integer转String
+                .collect(Collectors.joining(","));
+       return machineStr;
+    }
+
+    public String  getOperationStr() {
+
+
+        operationStr=   Optional.ofNullable(operationSequencing)
+                .orElse(Collections.emptyList())
+                .stream()
+                .map(String::valueOf) // Integer转String
                 .collect(Collectors.joining(","));
-        geneStr=machineStr+ "_" +operationStr;
+        return  operationStr;
     }
 
 
 
+
     /// <summary>
     /// 工序排序部分（工件/订单ID）
     /// </summary>
     private List<Integer> operationSequencing;
 
-    public void  setOperationSequencing(List<Integer> val) {
-        operationSequencing = val;
-        operationStr = operationSequencing.stream()
-                .map(String::valueOf) // 将每个 Integer 转换为 String
-                .collect(Collectors.joining(","));
-        geneStr=machineStr+ "_" +operationStr;
-    }
+
 
     /// <summary>
     /// 工序排序部分（工件/订单ID）
@@ -74,15 +91,17 @@ public class Chromosome {
 
 
     private  List<GlobalOperationInfo> globalOpList;
-    private  List<Entry> allOperations;
-    private  List<Order> orders;
+    private  CopyOnWriteArrayList<Entry> allOperations;
+    private  CopyOnWriteArrayList<Order> orders;
     private  List<Machine> InitMachines;
 
     private List<OrderMaterialRequirement> orderMaterials;
 
-    private List<GroupResult> OperatRel;
+    private CopyOnWriteArrayList<GroupResult> OperatRel;
 
     private ObjectiveWeights objectiveWeights;
+
+    List<Material> materials;
     /*
     * 最早完工时间（最小化） 最小化总加工时间 最小总换型时间
      */
@@ -147,7 +166,7 @@ public class Chromosome {
     private String ScenarioName;
     private LocalDateTime BaseTime ; // 当前基准时间
 
-
+    private List<Integer> reOrderids=new ArrayList<>();
 
 //
 //    //最大设备利用率

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

@@ -38,6 +38,8 @@ public class GAScheduleResult {
     private int changeOverTime;
     private int preTime;
     private  int seq; //工序顺序
+    private int bomTime;//物料齐套时间
+    private List<Integer> TargetFinishedOperationId;
 
     public int getFlowTime() {
         return EndTime - StartTime;

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

@@ -23,7 +23,7 @@ public class OrderMaterialRequirement {
         private String materialCode;
         private String materialName;
         private String materialTypeName;
-
+        private String bomId;
         /**
          * 物料类型
          */
@@ -92,7 +92,35 @@ public class OrderMaterialRequirement {
         /**
          * 检验周期
          */
-        private Long checkLeadTime;
+        private Integer checkLeadTime;
+
+        /**
+         * 采购周期
+         */
+        @TableField(exist = false)
+        private Integer purchaseTime;
+
+        /**
+         * 单价
+         */
+        @TableField(exist = false)
+        private BigDecimal price;
+
         @TableField(exist = false)
         private  List<OrderMaterialRequirement> replaceMaterial=new ArrayList<>();
+
+        @TableField(exist = false)
+        private double mainQty;
+
+        /**
+         * 物料需求数量
+         */
+        @TableField(exist = false)
+        private double spentQty;
+
+        /**
+         * 计划数量
+         */
+        @TableField(exist = false)
+        public double Quantity;
 }

src/main/java/com/aps/entity/Routingsupporting.java

@@ -15,7 +15,7 @@ private Long lastmodifieruserid;
 private Long isdeleted;
 private LocalDateTime deletiontime;
 private Long deleteruserid;
-private Long routingHeaderId;
+private Integer routingHeaderId;
 private Long routingDetailId;
 private String materialId;
 private String materialType;

src/main/java/com/aps/entity/Stock.java

 package com.aps.entity;
 
+import com.baomidou.mybatisplus.annotation.TableField;
 import lombok.Data;
 
 import java.math.BigDecimal;
@@ -24,7 +25,7 @@ private String storeCode;
 private String storeName;
 private double total;
 private Integer measureUnit;
-private BigDecimal totalLock;
+private double totalLock;
 private BigDecimal cost;
 private LocalDateTime productionDate;
 private LocalDateTime expiryDate;
@@ -37,4 +38,16 @@ private String supplierCode;
 private String supplierName;
 private Short warehousingUnitId;
 private String warehousingUnitName;
+
+    /*已用库存数*/
+    @TableField(exist = false)
+    private double usedInventory;
+
+    /*可用库存数*/
+    @TableField(exist = false)
+    private double availableInventory;
+
+    public double getAvailableInventory(){
+        return total-totalLock-usedInventory;
+    };
 }
\ No newline at end of file

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

@@ -2,6 +2,7 @@ package com.aps.entity.basic;
 
 
 import com.aps.entity.Algorithm.OperationDependency;
+import com.aps.entity.Algorithm.OrderMaterialRequirement;
 import com.aps.entity.RoutingDiscreteParam;
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
@@ -74,7 +75,7 @@ public class Entry {
     /**
      * 基因编号
      */
-    public Double Quantity;
+    public double Quantity;
     /**
      * 工序顺序
      */
@@ -112,7 +113,10 @@ public class Entry {
     /**
      * 所需物料
      */
-    public List<MaterialRequirement> MaterialRequirements ; // 所需物料
+    public List<OrderMaterialRequirement> MaterialRequirements ; // 所需物料
+
+
+
     /**
      * 设备资源组
      */
@@ -131,7 +135,7 @@ public class Entry {
     /// </summary>
     public List<Integer> TargetFinishedOperationId;
 
-    private boolean newCreate = false;
+    public boolean newCreate = false;
 
     /// <summary>
     /// 半成品最晚完工时间（即成品工序开始时间-1天）

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

+package com.aps.service.Algorithm;
+
+/**
+ * 作者：佟礼
+ * 时间：2026-01-27
+ */
+public class DataNode {
+        int id;
+    Integer time;
+        Integer groupId;
+        int no;
+
+        public DataNode(int id, Integer time, int groupId, int no) {
+            this.id = id;
+            this.time = time;
+            this.groupId = groupId;
+            this.no = no;
+        }
+
+        public int getGroupId() { return groupId; }
+        public long getTime() { return time; }
+        public int getNo() { return no; }
+
+        @Override
+        public String toString() {
+            return String.format("%d\t%d\t%d\t%d", id, time, groupId, no);
+        }
+}

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

@@ -14,7 +14,9 @@ import org.springframework.beans.factory.annotation.Autowired;
 import java.time.LocalDateTime;
 import java.util.*;
 import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 /**
  * 作者：佟礼
@@ -44,8 +46,10 @@ public class GeneticAlgorithm {
 
     private SceneService _sceneService;
 
+    private String sceneId;
+
     public GeneticAlgorithm(GlobalParam globalParam,List<Machine> machines, List<Order> orders,
-                                List<Material> materials, MachineSchedulerService machineScheduler,List<GroupResult> entryRel,MaterialRequirementService _materialRequirementService,SceneService sceneService) {
+                                List<Material> materials, MachineSchedulerService machineScheduler,List<GroupResult> entryRel,MaterialRequirementService _materialRequirementService,SceneService sceneService,String _sceneId) {
         this.machines = machines;
         this.orders = orders;
         this.materials = materials;
@@ -54,7 +58,7 @@ public class GeneticAlgorithm {
         _entryRel=entryRel;
         materialRequirementService=_materialRequirementService;
          _sceneService=sceneService;
-
+        sceneId=_sceneId;
     }
 
     public void Init(double[] customWeights, boolean pureNSGAIIMode) {
@@ -124,7 +128,7 @@ public class GeneticAlgorithm {
         {
             best.setBaseTime(param.getBaseTime());
             best.setOrderMaterials(orderMaterials);
-            best.setOperatRel(_entryRel);
+           // best.setOperatRel(_entryRel);
 
             if(best.getInitMachines()==null)
             {
@@ -264,7 +268,7 @@ public class GeneticAlgorithm {
         FileHelper.writeLogFile("迭代进化-----------结束-------");
         best.setBaseTime(param.getBaseTime());
         best.setOrderMaterials(orderMaterials);
-        best.setOperatRel(_entryRel);
+       // best.setOperatRel(_entryRel);
 
         if(best.getInitMachines()==null)
         {
@@ -299,19 +303,16 @@ public class GeneticAlgorithm {
             FileHelper.writeLogFile(String.format("排产-----------方案数量---%d-------",0 ));
 return population;
         }
-
-
-
-
-//        population = population.stream()
-//                .collect(Collectors.toMap(
-//                        Chromosome::getGeneStr, // key：去重的字段（GeneStr）
-//                        u -> u,        // value：Chromosome对象
-//                        (u1, u2) ->  u1 // 重复时保留第一个元素
-//                ))
-//                .values() // 获取去重后的
-//                .stream()
-//                .collect(Collectors.toList());
+        population = population.stream()
+                .filter(chromosome -> chromosome != null && chromosome.getGeneStr() != null)
+                .collect(Collectors.toMap(
+                        Chromosome::getGeneStr, // key：去重的字段（GeneStr）
+                        u -> u,        // value：Chromosome对象
+                        (u1, u2) ->  u1 // 重复时保留第一个元素
+                ))
+                .values() // 获取去重后的
+                .stream()
+                .collect(Collectors.toList());
 
         return  population;
     }
@@ -372,8 +373,8 @@ return population;
     {
          FileHelper.writeLogFile("解码---------------"+population.size() );
 
-        GeneticDecoder decoder = new GeneticDecoder(_GlobalParam, param.getBaseTime(), machines, orders, materials, machineScheduler,orderMaterials);
-        boolean ismore=true;
+        GeneticDecoder decoder = new GeneticDecoder(_GlobalParam, param.getBaseTime(), machines, orders, materials, machineScheduler,materialRequirementService, sceneId);
+        boolean ismore=false;
         if(ismore) {
             CompletableFuture.allOf(population.stream()
                             .map(chromosome -> CompletableFuture.runAsync(() -> decode(decoder, chromosome, param, allOperations, globalOpList), decodeExecutor))
@@ -382,7 +383,7 @@ return population;
 
         } else  {
             if (population != null && population.size() > 0) {
-                population.parallelStream().forEach(chromosome -> {
+                population.forEach(chromosome -> {
                     decode(decoder, chromosome, param, allOperations, globalOpList);
                 });
             }
@@ -403,8 +404,11 @@ return population;
         // 假设Machine类有拷贝方法，或使用MapStruct等工具进行映射
 
         chromosome.setMachines(ProductionDeepCopyUtil.deepCopyList(machines,Machine.class)); // 简单拷贝，实际可能需要深拷贝
+        chromosome.setOrders(ProductionDeepCopyUtil.deepCopyList(new CopyOnWriteArrayList<>(orders), Order.class) ); // 简单拷贝，实际可能需要深拷贝
+        chromosome.setOperatRel(ProductionDeepCopyUtil.deepCopyList(new CopyOnWriteArrayList<>(_entryRel), GroupResult.class) ); // 简单拷贝，实际可能需要深拷贝
+        chromosome.setMaterials(ProductionDeepCopyUtil.deepCopyList(materials,Material.class)); // 简单拷贝，实际可能需要深拷贝
 
-        chromosome.setAllOperations(allOperations); // 简单拷贝，实际可能需要深拷贝
+        chromosome.setAllOperations(ProductionDeepCopyUtil.deepCopyList(new CopyOnWriteArrayList<>(allOperations), Entry.class) ); // 简单拷贝，实际可能需要深拷贝
         chromosome.setGlobalOpList(globalOpList); // 简单拷贝，实际可能需要深拷贝
         //chromosome.setObjectiveWeights(_objectiveWeights);
         chromosome.setBaseTime(param.getBaseTime());
@@ -417,4 +421,6 @@ return population;
         }
     }
 
+
+
 }

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

@@ -5,8 +5,10 @@ import com.aps.entity.Algorithm.*;
 import com.aps.entity.basic.Entry;
 import com.aps.entity.basic.GlobalParam;
 import com.aps.entity.basic.MachineOption;
+import com.aps.entity.basic.Order;
 
 import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
@@ -132,7 +134,11 @@ public class GeneticOperations {
 
     // 重载，使用默认锦标赛大小3
     public List<Chromosome> tournamentSelection(List<Chromosome> population) {
-        return tournamentSelection(population, param.getTournamentSize());
+
+        List<Chromosome> populationn=  ProductionDeepCopyUtil.deepCopyList(tournamentSelection(population, param.getTournamentSize()),Chromosome.class);
+        populationn.parallelStream().forEach(t->DelOrder(t));
+
+        return  populationn;
     }
 
     /**
@@ -414,6 +420,49 @@ public class GeneticOperations {
 
         return indexWeights.get(CommonCalculator.getOsIndex(indexWeights));
     }
+    public void DelOrder(Chromosome chromosome) {
+        List<Entry> allOperations = chromosome.getAllOperations();
+        List<GlobalOperationInfo> globalOpList=  chromosome.getGlobalOpList();
+        List<Order> orders = chromosome.getOrders();
+        List<Integer> OperationSequencing=  chromosome.getOperationSequencing();
+        List<GAScheduleResult> ScheduleResults = chromosome.getResult();
+        List<Integer> newoorderids= orders.stream()
+                .filter(t->t.isNewCreate())
+                .map(Order::getId)
+                .sorted(Comparator.reverseOrder())
+                .collect(Collectors.toList());
+        if(newoorderids!=null&&newoorderids.size()>0) {
+            for (Integer id : newoorderids) {
+
+
+                List<Entry> sourceOps = allOperations.stream()
+                        .filter(o -> o.getGroupId()==id)
+                        .sorted(Comparator.comparing(Entry::getSequence))
+                        .collect(Collectors.toList());
+
+                for (Entry entry : sourceOps) {
+                    OptionalInt index1 = IntStream.range(0, globalOpList.size())
+                            .filter(h -> entry.getId()==globalOpList.get(h).getOp().getId())
+                            .findFirst();
+                    globalOpList.remove((int)index1.orElse(0));
+
+                    chromosome.getMachineSelection().remove((int)index1.orElse(0));
+                }
+
+                chromosome.getOperatRel().remove(id-1);
+
+            }
+            allOperations.removeIf(t ->newoorderids.contains(t.getGroupId()));
+            OperationSequencing.removeIf(t ->newoorderids.contains(t));
+            AtomicInteger globalOpId = new AtomicInteger(0);
+            globalOpList.forEach(t-> {
+
+                t.setGlobalOpId(globalOpId.getAndIncrement());
+
+            });
+            orders.removeIf(t ->newoorderids.contains(t.getId()));
+        }
+    }
 
 
 }

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

@@ -8,6 +8,7 @@ import com.aps.entity.Algorithm.ScheduleParams;
 import com.aps.entity.basic.*;
 
 import java.util.*;
+import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
@@ -25,6 +26,10 @@ public class Initialization {
 
     private ObjectiveWeights _objectiveWeights = new ObjectiveWeights();
 
+    public Initialization() {
+
+    }
+
     public Initialization(GlobalParam globalParam,List<Entry> allOperations,List<Order> _orders,List<Machine> _machines,ObjectiveWeights objectiveWeights) {
         Initialization.allOperations = allOperations;
         _globalParam= globalParam;
@@ -66,14 +71,17 @@ int populationSize=param.getPopulationSize();
                     Chromosome chromo = new Chromosome(); // 初始化染色体
                    // chromo.setObjectiveWeights(_objectiveWeights);
                    // chromo.setInitMachines(ProductionDeepCopyUtil.deepCopyList(machines));
-chromo.setOrders(orders);
+chromo.setOrders(new CopyOnWriteArrayList<>(orders));
                     // 全局选择（GS）：按GlobalOpId顺序生成MachineSelection
                     if (i < gsCount) {
+                        chromo.setGsOrls(1);
                         generateGSChromosome(chromo,globalOpList); // 对应 C# GenerateGSChromosome
                     } else if (i < lsCount) {
+                        chromo.setGsOrls(2);
                         // 局部选择（LS）：按GlobalOpId顺序生成MachineSelection（仅负载计算范围不同）
                         generateLSChromosome(chromo,globalOpList);
                     } else {
+                        chromo.setGsOrls(3);
                         //  随机选择（RS）：按GlobalOpId顺序生成MachineSelection（仅机器选择随机）
                         generateRSChromosome(chromo,globalOpList);
                     }
@@ -87,6 +95,31 @@ chromo.setOrders(orders);
 
         return population;
     }
+
+
+    public List<Chromosome> generateInitialSFPopulation(Chromosome chromo, List<GlobalOperationInfo> globalOpList) {
+        List<Chromosome> population = new ArrayList<>();
+
+
+        // 并行循环：对应 Parallel.For(0, PopulationSize, i => { ... })
+
+        if (chromo.getGsOrls()==1) {
+            generateGSChromosome(chromo,globalOpList); // 对应 C# GenerateGSChromosome
+        } else if (chromo.getGsOrls()==2) {
+            // 局部选择（LS）：按GlobalOpId顺序生成MachineSelection（仅负载计算范围不同）
+            generateLSChromosome(chromo,globalOpList);
+        } else {
+            //  随机选择（RS）：按GlobalOpId顺序生成MachineSelection（仅机器选择随机）
+            generateRSChromosome(chromo,globalOpList);
+        }
+
+
+
+
+        return population;
+    }
+
+
     /**
      * 全局选择（GS）生成染色体（按GlobalOpId顺序生成MachineSelection）
      */
@@ -145,9 +178,17 @@ chromo.setOrders(orders);
             osp.clear();
         }
 
-        // 步骤2：打乱工序排序部分（OS）
-        chromosome.setOperationSequencing(shuffleWithPriority(os));
-        chromosome.setMachineSelection(ms);
+        if(chromosome.getOperationSequencing()!=null&&chromosome.getOperationSequencing().size()>0)
+        {
+            chromosome.getOperationSequencing().addAll(os);
+            chromosome.getMachineSelection().addAll(ms);
+
+        }else {
+            // 步骤2：打乱工序排序部分（OS）
+            chromosome.setOperationSequencing(shuffleWithPriority(os));
+
+            chromosome.setMachineSelection(ms);
+        }
 
         return chromosome;
     }
@@ -215,9 +256,15 @@ chromo.setOrders(orders);
             os.addAll(osp);
             osp.clear();
         }
-
-        chromosome.setOperationSequencing(shuffleWithPriority(os));
-        chromosome.setMachineSelection(ms);
+        if(chromosome.getOperationSequencing()!=null&&chromosome.getOperationSequencing().size()>0)
+        {
+            chromosome.getOperationSequencing().addAll(os);
+            chromosome.getMachineSelection().addAll(ms);
+
+        }else {
+            chromosome.setOperationSequencing(shuffleWithPriority(os));
+            chromosome.setMachineSelection(ms);
+        }
 
         return chromosome;
     }
@@ -259,9 +306,15 @@ chromo.setOrders(orders);
             os.addAll(osp);
             osp.clear();
         }
-
-        chromosome.setOperationSequencing(shuffleWithPriority(os));
-        chromosome.setMachineSelection(ms);
+        if(chromosome.getOperationSequencing()!=null&&chromosome.getOperationSequencing().size()>0)
+        {
+            chromosome.getOperationSequencing().addAll(os);
+            chromosome.getMachineSelection().addAll(ms);
+
+        }else {
+            chromosome.setOperationSequencing(shuffleWithPriority(os));
+            chromosome.setMachineSelection(ms);
+        }
 
         return chromosome;
     }

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

@@ -597,7 +597,7 @@ if(targetOp.getSequence()>1) {
                 OperatRels = IdGroupingWithDualSerial.addNode(OperatRels, targetGroupIndex, newId, newParentIds, newChildIds,targetOp.getExecId());
             }
          }
-        chromosome.setOperatRel(OperatRels);
+        chromosome.setOperatRel(new CopyOnWriteArrayList<>(OperatRels) );
         //当前组的
          groupResult = OperatRels.get(targetGroupIndex);
 
@@ -799,7 +799,7 @@ if(targetOp.getSequence()>1) {
 
         // 添加新数据
         OperatRels = IdGroupingWithDualSerial.addNewDataWithIsolatedGroup(OperatRels, newIdList, newChildIdList);
-        chromosome.setOperatRel(OperatRels);
+        chromosome.setOperatRel(new CopyOnWriteArrayList<>(OperatRels) );
         //全局ID
         int globalOpId = chromosome.getGlobalOpList().stream()
                 .mapToInt(GlobalOperationInfo::getGlobalOpId)
@@ -986,7 +986,7 @@ if(targetOp.getSequence()>1) {
         List<GroupResult> OperatRels = chromosome.getOperatRel();
 
         OperatRels = IdGroupingWithDualSerial.deleteNodeByGlobalSerial(OperatRels, opId);
-        chromosome.setOperatRel(OperatRels);
+        chromosome.setOperatRel(new CopyOnWriteArrayList<>(OperatRels) );
         Entry targetOp = allOperations.stream()
                 .filter(o -> o.getId() == opId)
                 .findFirst()
@@ -1184,7 +1184,7 @@ if(targetOp.getSequence()>1) {
         chromosome.setMachines(ProductionDeepCopyUtil.deepCopyList(chromosome.getInitMachines(),Machine.class) );
 
         GeneticDecoder decoder = new GeneticDecoder(globalParam,baseTime, chromosome.getMachines(),
-                chromosome.getOrders(), null, machineScheduler,chromosome.getOrderMaterials());
+                chromosome.getOrders(), null, machineScheduler,null,chromosome.getScenarioID());
         chromosome.setResultOld(ProductionDeepCopyUtil.deepCopyList(chromosome.getResult(),GAScheduleResult.class));
 
         chromosome.getResult().clear();

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

+package com.aps.service.Algorithm;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * 作者：佟礼
+ * 时间：2026-01-27
+ */
+public class TestSortService {
+    public  void test() {
+        List<DataNode> list = new ArrayList<>();
+        // 初始化数据
+        list.add(new DataNode(1, 18000, 1, 1));
+        list.add(new DataNode(2, 882000, 1, 2));
+        list.add(new DataNode(3, 2260078, 2, 1));
+        list.add(new DataNode(4, 2695678, 2, 2));
+        list.add(new DataNode(5, 0, 3, 1));
+        list.add(new DataNode(6, 950400, 3, 2));
+        list.add(new DataNode(7, 0, 4, 1));
+        list.add(new DataNode(8, 18000, 4, 2));
+        list.add(new DataNode(9, 3419998, 5, 1));
+        list.add(new DataNode(10, 1022646, 5, 2));
+
+        // 1. 预处理：计算每个 groupId 对应的最小时间（作为该组的排位基准）
+        Map<Integer, Long> groupMinTimeMap = list.stream()
+                .collect(Collectors.groupingBy(
+                        DataNode::getGroupId,
+                        Collectors.mapping(DataNode::getTime, Collectors.minBy(Long::compare))
+                ))
+                .entrySet().stream()
+                .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().orElse(0L)));
+
+        // 2. 执行排序
+        list.sort((a, b) -> {
+            // 首先比较所属组的基准时间
+            long minTimeA = groupMinTimeMap.get(a.getGroupId());
+            long minTimeB = groupMinTimeMap.get(b.getGroupId());
+
+            if (minTimeA != minTimeB) {
+                return Long.compare(minTimeA, minTimeB);
+            }
+
+            // 如果基准时间相同（比如 group3 和 group4 都是 0），则按 groupId 排序(可选)
+            if (a.getGroupId() != b.getGroupId()) {
+                return Integer.compare(a.getGroupId(), b.getGroupId());
+            }
+
+            // 同一组内，按 no 升序
+            return Integer.compare(a.getNo(), b.getNo());
+        });
+
+        // 输出结果
+        System.out.println("ID\ttime\tgroupid\tno");
+        list.forEach(System.out::println);
+    }
+
+    public static List<DataNode> customSort(List<DataNode> dataList) {
+        // 按groupId分组
+        Map<Integer, List<DataNode>> groupMap = dataList.stream()
+                .collect(Collectors.groupingBy(data -> data.groupId));
+
+        // 对每个组内的数据按no升序排序
+        groupMap.values().forEach(group ->
+                group.sort(Comparator.comparingInt(data -> data.no))
+        );
+
+        // 计算每个组的最小时间（用于组间排序）
+        Map<Integer, Long> groupMinTime = new HashMap<>();
+        for (Map.Entry<Integer, List<DataNode>> entry : groupMap.entrySet()) {
+            long minTime = entry.getValue().stream()
+                    .mapToLong(data -> data.time)
+                    .min()
+                    .orElse(Long.MAX_VALUE);
+            groupMinTime.put(entry.getKey(), minTime);
+        }
+
+        // 将组按最小时间排序，然后展开
+        return groupMap.entrySet().stream()
+                .sorted(Map.Entry.comparingByValue((list1, list2) ->
+                        Long.compare(groupMinTime.get(list1.get(0).groupId),
+                                groupMinTime.get(list2.get(0).groupId))))
+                .flatMap(entry -> entry.getValue().stream())
+                .collect(Collectors.toList());
+    }
+
+    // 更简洁的写法
+    public static List<DataNode> customSort2(List<DataNode> dataList) {
+        // 按groupId分组并在组内按no排序
+        Map<Integer, List<DataNode>> groupMap = dataList.stream()
+                .collect(Collectors.groupingBy(
+                        data -> data.groupId,
+                        Collectors.collectingAndThen(
+                                Collectors.toList(),
+                                list -> {
+                                    list.sort(Comparator.comparingInt(d -> d.no));
+                                    return list;
+                                }
+                        )
+                ));
+
+        // 将组转为列表并按组内最小时间排序
+        List<List<DataNode>> sortedGroups = new ArrayList<>(groupMap.values());
+        sortedGroups.sort(Comparator.comparing(
+                group -> group.stream().mapToLong(d -> d.time).min().orElse(Long.MAX_VALUE)
+        ));
+
+        // 展开所有组
+        return sortedGroups.stream()
+                .flatMap(List::stream)
+                .collect(Collectors.toList());
+    }
+    public static List<DataNode> sortData(List<DataNode> data) {
+        // 步骤1: 找出每个groupid的最小time
+        Map<Integer, Integer> groupMinTime = data.stream()
+                .collect(Collectors.groupingBy(
+                        item -> item.groupId,
+                        Collectors.mapping(item -> item.time,
+                                Collectors.collectingAndThen(
+                                        Collectors.toList(),
+                                        list -> list.stream().min(Integer::compareTo).orElse(0)
+                                ))
+                ));
+
+        // 步骤2: 按照以下规则排序
+        List<DataNode> sorted = new ArrayList<>(data);
+        sorted.sort((a, b) -> {
+            int aMinTime = groupMinTime.get(a.groupId);
+            int bMinTime = groupMinTime.get(b.groupId);
+
+            // 首先按照group的最小time排序
+            if (aMinTime != bMinTime) {
+                return Integer.compare(aMinTime, bMinTime);
+            }
+
+            // 如果group最小time相同，按groupid排序
+            if (a.groupId != b.groupId) {
+                return Integer.compare(a.groupId, b.groupId);
+            }
+
+            // 同一个group内，按no排序
+            return Integer.compare(a.no, b.no);
+        });
+
+        return sorted;
+    }
+
+    public  void test1() {
+        // 创建测试数据
+        List<DataNode> originalData = Arrays.asList(
+                new DataNode(1, 18000, 1, 1),
+                new DataNode(2, 882000, 1, 2),
+                new DataNode(3, 2260078, 2, 1),
+                new DataNode(4, 2695678, 2, 2),
+                new DataNode(5, 0, 3, 1),
+                new DataNode(6, 950400, 3, 2),
+                new DataNode(7, 0, 4, 1),
+                new DataNode(8, 18000, 4, 2),
+                new DataNode(9, 3419998, 5, 1),
+                new DataNode(10, 1022646, 5, 2)
+        );
+
+        System.out.println("排序前:");
+        originalData.forEach(System.out::println);
+
+        System.out.println("\n排序后:");
+        List<DataNode> sortedData = sortData(originalData);
+        sortedData.forEach(System.out::println);
+    }
+
+
+}

src/main/resources/application.yml

@@ -10,8 +10,8 @@ spring:
     pathmatch:
       matching-strategy: ant_path_matcher  # Spring Boot 2.6+ 需要这个配置
   redis:
-    host: 192.168.0.181
-    port: 6380
+    host: 39.100.88.40
+    port: 6379
     timeout: 120000
     database: 10
     password: redis@228!
@@ -55,7 +55,7 @@ spring:
         # Oracle数据源
         oracle:
           driver-class-name: oracle.jdbc.OracleDriver
-          url: jdbc:oracle:thin:@//192.168.0.181:1522/ORCLPDB1 # ORCL为你的Oracle实例名
+          url: jdbc:oracle:thin:@//39.100.78.207:7002/ORCLPDB1 # ORCL为你的Oracle实例名
           username: mes  # 替换为你的Oracle用户名
           password: root_mes123456  # 替换为你的Oracle密码
 #        sqlserver:

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

@@ -8,6 +8,7 @@ import com.aps.entity.Gantt.ProductGanttVO;
 import com.aps.entity.basic.Machine;
 import com.aps.entity.basic.MaintenanceWindow;
 import com.aps.service.Algorithm.NSGAIIUtils;
+import com.aps.service.Algorithm.TestSortService;
 import com.aps.service.plan.PlanResultService;
 import com.aps.service.plan.SceneService;
 import org.junit.jupiter.api.Test;
@@ -35,15 +36,16 @@ public class PlanResultServiceTest {
 //        Chromosome chromosome=  planResultService.moveChromosome("qwerty",3);
        // planResultService.execute2("B7881EF032044B9BA4F6007875510B70");
        // NSGAIIUtils nsgaiiUtils=new NSGAIIUtils();
-
+      //  TestSortService  sortService=new TestSortService();
+     //  sortService.test1();
        // nsgaiiUtils.Test();
-        planResultService.execute2("0DCB1301C57C48B68154789B0FAB8B98");
+       planResultService.execute2("83D729F5E0694F25A71614B1991D7457");
        //  planResultService.execute2("726D4C1A712B4B1393175BD44B775B66");
     //   planResultService.execute2("265F24B6DF3C40E4B17D193B0CC8AAF2");
 //        LocalDateTime t=   LocalDateTime.of(2026, 02, 14, 1, 25, 52);
  //      List<Integer> opids=new ArrayList<>();//BCA6FA43FFA444D3952CF8F6E1EA291B
 //       opids.add(7);
-//        planResultService.Move("27065EA0ECD14A81B7FAAFEF52273F93",opids,t,1265l,0);
+     //   planResultService.Move("27065EA0ECD14A81B7FAAFEF52273F93",opids,t,1265l,0);
 // planResultService.Redecode("27065EA0ECD14A81B7FAAFEF52273F93");
    //     planResultService.Redecode("CA71321FE55B4437A3900315692F9220");
  //       planResultService.Drag("27065EA0ECD14A81B7FAAFEF52273F93",opids,6,false,0l);