An end-to-end finite element analysis system based on multi-agent cooperation

Abstract

The application relates to the technical field of finite element simulation analysis, and particularly discloses an end-to-end finite element analysis system based on multi-agent cooperation, which is constructed by taking a central coordinator agent as the core of a hierarchical multi-agent cooperative architecture, is matched with a general standardized decoupling interface system of the whole system, builds a knowledge base pedestal that can be dynamically updated, and realizes accurate intention analysis and task scheduling and execution of the whole simulation process in combination with a large language model, thereby breaking through the inherent limitation of the simple series connection architecture of the existing technology flat-level agent, solving the core defects of the existing scheme, such as high coupling degree between agents, non-uniform interfaces, poor scalability, and the inability to flexibly adapt to complex industrial simulation scenes such as multi-working-condition parallelism and multi-physical-field coupling, realizing complete decoupling and flexible expansion of the agents, and having obvious architectural advancement compared with the existing flat-level series connection architecture.

Description

Technical Field

[0001] This application relates to the field of finite element simulation analysis technology, and specifically discloses an end-to-end finite element analysis system based on multi-agent collaboration. Background Technology

[0002] With the rapid development of intelligent manufacturing and high-end equipment R&D technologies, computer-aided engineering simulation has become a core supporting link for product development, performance verification, and structural optimization in fields such as aerospace, automobiles, engineering machinery, and rail transportation.

[0003] Traditional computer-aided engineering simulation follows a standard workflow: geometry processing, mesh generation, simulation solution, results analysis, and report generation. This workflow is inherently linear and fragmented, with each step heavily reliant on manual operation and professional judgment by engineers. If an error occurs at any stage, the entire simulation process must be interrupted and await manual investigation and correction. This inherent pattern of stopping after an error and then intervening manually not only leads to long product simulation iteration cycles and low R&D efficiency, but also makes it difficult to guarantee the consistency and reproducibility of simulation results across different scenarios and with different operators because the entire simulation process heavily depends on the individual experience of engineers.

[0004] Therefore, the industry generally regards the automation and intelligentization of simulation analysis processes as the core solution. Multi-agent systems encapsulate individual steps in the simulation process, such as geometry cleanup, mesh generation, and physical modeling, into autonomous agents with independent processing capabilities. These agents collaborate to transform the traditional linear simulation process into a dynamically programmable intelligent workflow, enabling the simulation process to flexibly adapt to different simulation scenarios. However, existing multi-agent systems still employ a simple serial architecture of parallel agents, lacking a hierarchical central coordination and control mechanism. Furthermore, the high coupling between agents, inconsistent interfaces, and poor scalability result in an inability to flexibly adapt to complex industrial simulation scenarios such as parallel operation under multiple operating conditions and coupling of multiple physics fields.

[0005] In addition, the existing technologies and similar solutions in the industry can only achieve simple multi-task parallel solutions, and cannot force the consistency of the benchmark model between multiple operating conditions. This results in the simulation results of different operating conditions being incomparable and cannot meet the comparative verification needs of batch simulation in industrial scenarios.

[0006] This invention provides an end-to-end finite element analysis system based on multi-agent collaboration to solve the above-mentioned problems. Summary of the Invention

[0007] The purpose of this invention is to address the shortcomings of existing multi-agent finite element simulation systems in terms of poor adaptability to multiple operating conditions, so as to achieve end-to-end intelligent simulation and collaborative optimization under multiple operating conditions.

[0008] To achieve the above objectives, the basic solution of the present invention provides an end-to-end finite element analysis system based on multi-agent collaboration, including a knowledge base and a multi-agent framework.

[0009] The knowledge base is used to store the underlying data related to the entire process of finite element simulation analysis. The underlying data includes at least error diagnosis modes, simulation experience rules, and simulation cases.

[0010] The multi-agent framework includes a central coordinator agent and multiple agents.

[0011] The central coordinator agent is communicatively connected to the knowledge base and the multiple agents, respectively, and is used to receive user input, parse the user input based on the knowledge base and generate structured tasks, and uniformly coordinate and manage the multiple agents to execute the simulation links corresponding to the structured tasks.

[0012] The plurality of intelligent agents are respectively connected to the central coordinator intelligent agent for executing their respective simulation tasks under the unified coordination and control of the central coordinator intelligent agent, and for feeding back the execution status and simulation results to the central coordinator intelligent agent.

[0013] All agents within the multi-agent framework use a unified standardized interface for data interaction. During the data interaction process, only the central coordinator agent has the authority to actively issue tasks. There is no direct call between the other agents, and all cross-agent data interactions are forwarded through the central coordinator.

[0014] The central coordinator intelligent agent has a built-in multi-condition parallel scheduling module. When the user input includes multiple parallel simulation conditions, the multi-condition parallel scheduling module is used to identify the common and individual parameters of the parallel conditions, merge the common execution links into a common parent task, split the individual execution links of each condition into parallel sub-tasks, construct a tree-shaped task structure of common parent task and parallel sub-tasks, allocate execution priority and computing resources to each parallel sub-task, and control the execution sequence of parallel tasks.

[0015] The central coordinator agent has built-in multi-condition benchmark consistency mandatory control rules, and after all parallel subtasks are executed, it summarizes the simulation results of all conditions and performs cross-condition collaborative optimization based on the multi-condition results.

[0016] Furthermore, the central coordinator agent is equipped with a large language model, which is fine-tuned using labeled data from the finite element simulation domain. The large language model is used to parse the natural language input by the user based on the knowledge base, extract the simulation intent and key parameters, and generate standardized structured tasks.

[0017] Furthermore, the central coordinator agent is specifically used for:

[0018] The structured task is divided into predetermined modules, including at least a mesh control module, a simulation solution control module, and a result analysis control module;

[0019] The mesh control module is sent to the mesh generation agent, the simulation solution control module is sent to the simulation solution agent, and the result analysis control module is sent to the result analysis agent, so as to serve as standardized inputs for each agent to perform the corresponding simulation task.

[0020] Furthermore, the multi-condition benchmark consistency mandatory control rule is as follows: a unique benchmark model is generated in the common parent task stage. The benchmark model includes a benchmark geometry model and a benchmark mesh model. All parallel subtasks must be executed based on this unique benchmark model. Only three types of individual parameters, namely load, material, and boundary conditions, can be modified. Subtasks are prohibited from modifying the benchmark geometry and benchmark mesh. All parallel subtasks execute a unified mesh quality standard, solution convergence standard, and result extraction rule.

[0021] Furthermore, the specific process of the multi-condition parallel scheduling module performing cross-condition collaborative optimization is as follows:

[0022] The simulation results of all parallel subtasks are summarized. The performance indicators of all working conditions meet the design allowable value as a constraint. The performance indicators of all working conditions are used as optimization objectives. Structural geometric parameters and material parameters are used as optimization variables. The value range of each optimization variable is used to construct a design space. The space filling sampling method is used to automatically generate supplementary sampling points in the design space. Each agent is driven to complete the supplementary simulation calculation. The supplementary simulation results are merged with the original parallel working condition simulation results to form a full training sample set covering the design space.

[0023] A multi-objective optimization agent model is constructed based on the full training sample set. A global optimization is performed through a multi-objective optimization algorithm to obtain a Pareto optimal solution set. After selecting the optimal solution from the Pareto optimal solution set based on the optimization priority input by the user, the model automatically drives each agent to perform verification simulation and finally outputs the optimal structural scheme and verification results.

[0024] Furthermore, the central coordinator intelligent agent has a built-in multi-physics coupling collaborative management and control module. When the user input is multi-physics coupling analysis, the multi-physics coupling collaborative management and control module is used to decompose the physical field composition, data transmission direction and coupling iteration rules of the coupling field, plan the execution sequence of each physical field analysis, create an independent simulation solution subtask for each physical field analysis, and manage the execution start and stop and data transmission of each subtask.

[0025] Furthermore, the multi-physics coupling collaborative management module monitors the iterative convergence status of each physics subtask in real time for bidirectional coupling analysis. When the calculation results of all physics reach the convergence threshold or the maximum number of iterations, the coupling iteration process is terminated.

[0026] The results data between different physical field subtasks are all converted and forwarded in a standardized format by the central coordinator agent.

[0027] Furthermore, the central coordinator intelligent agent has a built-in full-process status monitoring and closed-loop management module, which is used for:

[0028] Real-time monitoring of the heartbeat packets and execution progress feedback of each agent; creation and updating of a full-process state machine containing the sub-states of each execution stage for the simulation task.

[0029] Based on the judgment results of the full-process state machine, control commands, including normal process progress, pause, backtracking, restart or termination, are issued to each intelligent agent.

[0030] Furthermore, the full-process status monitoring and closed-loop management module is also used for:

[0031] Pre-defined compliance verification rules are set for the execution results of each simulation stage, and the verification rules are derived from the knowledge base;

[0032] The task issuance for the next stage will only be triggered after the execution result of the current stage passes the compliance check.

[0033] The principle and effect of this solution are as follows:

[0034] 1. Compared with existing technologies, this invention constructs a hierarchical multi-agent collaborative architecture with a central coordinator agent as the core, supports a system-wide standardized decoupling interface system, builds a dynamically updatable knowledge base, and combines a large language model to achieve accurate intent parsing and task scheduling and execution throughout the simulation process. This overcomes the inherent defects of the simple serial architecture of peer-level agents in existing technologies, and solves the core defects of existing solutions such as high coupling between agents, inconsistent interfaces, poor scalability, and inability to flexibly adapt to complex industrial simulation scenarios such as multi-condition parallelism and multi-physics coupling. It achieves complete decoupling and flexible expansion of each agent.

[0035] 2. Compared with existing technologies, this invention establishes a real-time monitoring mechanism for the entire process execution status and a cross-stage anomaly root cause tracing and linkage repair system, constructing a complete closed-loop autonomous process from perception, planning, execution, and repair. This solves the problems of traditional simulation processes and existing intelligent agent solutions, which can only achieve forward process automation, cannot handle cross-stage chain anomalies, cannot get rid of errors and stop, and cannot be repaired by manual intervention. This reduces the dependence of the entire finite element simulation process on the personal experience of engineers, significantly improves the efficiency of simulation analysis, the consistency and reproducibility of simulation results, and shortens the simulation iteration cycle of high-end equipment product development.

[0036] 3. Compared with existing technologies, this invention ensures the horizontal comparability of simulation results of all parallel operating conditions by enforcing consistency control of multi-operating condition benchmarks, thus solving the defect of incomparability of results of existing multi-operating condition schemes. At the same time, through cross-operating condition collaborative optimization, it realizes an end-to-end closed loop from multi-operating condition parallel simulation to global structural optimization, shortening the original multi-operating condition simulation-manual comparison-structural optimization-iterative verification process that required several weeks to complete automatically within a few hours, greatly reducing reliance on manual labor. Attached Figure Description

[0037] To more clearly illustrate the technical solutions in the embodiments of this application, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0038] Figure 1 A schematic diagram of an end-to-end finite element analysis system based on multi-agent cooperation proposed in an embodiment of this application is shown.

[0039] Figure 2 A schematic diagram of an end-to-end finite element analysis system based on multi-agent cooperation under a single working condition, as proposed in an embodiment of this application, is shown.

[0040] Figure 3 This illustration shows a schematic diagram of an end-to-end finite element analysis system based on multi-agent cooperation under multiple operating conditions, as proposed in an embodiment of this application. Detailed Implementation

[0041] To further illustrate the technical means and effects of the present invention in achieving its intended purpose, the following detailed description of the specific implementation methods, structures, features, and effects of the present invention, in conjunction with the accompanying drawings and preferred embodiments, is provided below.

[0042] An end-to-end finite element analysis system based on multi-agent collaboration, implementing, for example... Figure 1 As shown, it includes: a knowledge base and a multi-agent framework.

[0043] It should be noted that in this invention, each intelligent agent interacts with the central coordinator intelligent agent through a unified standardized interface. The finite element software calling layer inside each intelligent agent is a replaceable and independent adaptation module, and this invention is not limited to a specific software combination. The following embodiments use HyperMesh as the geometry preprocessing and mesh generation tool and OptiStruct as the simulation solver for illustrative purposes. For implementation scenarios using other finite element software, such as using ANSA instead of HyperMesh for geometry preprocessing and mesh generation, or using ANSYS Mechanical or Abaqus instead of OptiStruct for simulation solving, only the software calling adaptation logic inside the corresponding intelligent agent needs to be replaced with the corresponding implementation of the API interface or script interface provided by the target software. The standardized interface format exposed by each intelligent agent, the scheduling logic of the central coordinator intelligent agent, and the whole-process control mechanism remain completely unchanged. This is a conventional software adaptation task that can be directly completed by those skilled in the art based on the architecture description of this invention.

[0044] The knowledge base serves as the core data support and shared knowledge foundation for the entire system. It stores underlying data related to the entire finite element simulation analysis process, providing foundational data support for error diagnosis, rule matching, strategy recommendation, and case reference. The knowledge base is built upon data from the historical simulation process and includes three interconnected and data-interoperable sub-repositories: an error diagnosis pattern library, a simulation experience library, and a simulation case library. The specific implementation details of each sub-repository are as follows:

[0045] The error diagnosis mode library contains various common error modes in the entire finite element simulation analysis process, as well as standardized solutions corresponding to each error mode, providing direct diagnostic basis and handling solutions for anomaly handling and automated repair during the simulation process.

[0046] The simulation experience library provides the system with standardized rules and industry practices in the field of engineering simulation, and includes five core data categories: physical verification rules, domain engineering design guidelines, optimization strategy templates, failure mode data, and practice guidelines. Specifically:

[0047] Physical verification rules include, but are not limited to, safety factor, fatigue life, deformation limit, buckling stability, stress concentration, resonance risk, and thermal stress-related judgment criteria.

[0048] Engineering design guidelines for the field, including but not limited to industry design specifications and guidelines for aerospace structures, rotating machinery, pressure vessels, and structural efficiency indicators.

[0049] Optimize strategy templates, including but not limited to root cause analysis logic for various simulation anomalies, specific optimization schemes, decision-making logic, and historical success rate data of the schemes.

[0050] Failure mode data, including but not limited to failure criteria and handling experience related to yielding, high-cycle fatigue, elastic buckling, resonance, excessive deformation, and stress concentration cracks.

[0051] Practice guidelines, including but not limited to standardized operating procedures for mesh quality control, boundary condition settings, result verification methods, material selection specifications, and simulation optimization processes.

[0052] The simulation case library contains a collection of successful historical finite element simulation analysis cases. It stores all the data for each successful case, including material parameters, mesh generation strategies, load and boundary condition settings, solver configuration parameters, and simulation analysis results. This provides reusable case references and parameter matching basis for new simulation tasks.

[0053] In this embodiment, the knowledge base adopts a combined architecture of relational database and vector database, with standardized data structures for all three sub-bases. The error diagnosis pattern database includes fixed fields such as unique error identifier, error pattern code, occurrence stage, characteristic keywords, repair plan, and historical call data. The simulation experience database is divided into five sub-tables to store physical verification rules, domain engineering design guidelines, optimization strategy templates, failure mode data, and practice guidelines, respectively. Each sub-table includes fixed fields such as unique rule identifier, applicable scenario, rule content, industry source, and historical matching data. The simulation case database includes fixed fields such as unique case identifier, analysis type, industry domain, key parameters of the entire process, simulation results, entry time, and historical call data.

[0054] The multi-agent framework comprises a central coordinator agent, a geometry preprocessing agent, a mesh generation agent, a simulation solving agent, a result analysis agent, and a report generation agent. The central coordinator agent is deployed on the main control server, while the geometry preprocessing agent, mesh generation agent, simulation solving agent, result analysis agent, and report generation agent can be deployed on the same server or distributed computing nodes. The central coordinator agent serves as the core scheduling hub of the system, receiving user input and coordinating and managing the task execution, data interaction, and anomaly handling of each agent. Based on the scheduling of the central coordinator agent, the multi-agent framework sequentially completes the end-to-end finite element analysis process, encompassing task analysis, geometry preprocessing, mesh generation, simulation solving, result analysis, and report generation.

[0055] User input includes natural language descriptions and geometric model files. Natural language descriptions include, but are not limited to, simulation intent, boundary conditions, loads, and material properties. The natural language descriptions are matched with the provided geometric model files; that is, the simulation analysis object pointed to by the natural language description is consistent with the structural entity corresponding to the geometric model file, and the positions of parameters such as loads, boundary conditions, and regions of interest in the natural language description correspond one-to-one with the corresponding geometric features in the geometric model file. The geometric model file can be in STEP format or other commonly used CAD model formats in this field.

[0056] The central coordinator agent is equipped with a large language model. Based on this model, it parses the natural language descriptions input by the user to obtain simulation intent and key parameters, formulates and assigns tasks according to predetermined rules, and achieves multi-level intent understanding. In this embodiment, the large language model is the DeepSeek-R1 model, which has been fine-tuned based on a finite element simulation domain annotation dataset. The finite element simulation domain annotation dataset is constructed as follows: natural language simulation requirement description texts are collected from historical simulation project engineering records, simulation software operation manuals, industry standards and specifications, and publicly available simulation tutorials. Engineers with finite element simulation engineering experience manually annotate each text. The annotation output is a corresponding structured JSON format key-value pair, including simulation intent categories such as static analysis, modal analysis, thermal analysis, fatigue analysis, etc., as well as all key parameters such as mesh parameters, material parameters, load conditions, and boundary conditions.

[0057] The process of parsing user input is completed by the central coordinator agent through its built-in large language model. The large language model understands the engineering semantics from the natural language description and parses out the simulation intent and key parameters. The simulation intent parsed by the large language model includes, for example, modal analysis and fatigue analysis. The key parameters parsed out include, for example, global mesh parameters, material parameters, loading conditions, boundary conditions, analysis type, and analysis items. Material matching and load strategy determination are performed by searching the knowledge base.

[0058] In this embodiment, the vectorized retrieval of the knowledge base is uniformly initiated, controlled, and processed by the central coordinator agent, following this process: The central coordinator agent preprocesses the input retrieval text, including removing meaningless stop words and extracting semantic keywords. Then, using the all-MiniLM-L6-v2 model from the sentence-transformers family, the preprocessed retrieval text is encoded into a 384-dimensional semantic vector. In this example, the encoding parameters of the all-MiniLM-L6-v2 model are fixed as follows: maximum sequence length 128, mean pooling, and L2 normalization of the output vector. These parameters are completely consistent with those used when the knowledge base is loaded. In this embodiment, a vector database, such as Milvus, is used to store the semantic vectors; alternatively, a database like Qdrant could also be used.

[0059] Subsequently, the similarity between semantic vectors and knowledge base entries is calculated using a cosine similarity algorithm in the vector database. Results with high similarity rankings are returned, and finally, a central coordinator agent filters out results that do not meet the similarity threshold. In this embodiment, the cosine similarity threshold is set to ≥0.75. The remaining results are then sorted by weighted similarity and historical call count, and the highest-ranking matching result is returned. In this embodiment, the weighting of the results is as follows: similarity accounts for 70%, and the normalized historical call count accounts for 30%, sorted from highest to lowest weighted total score.

[0060] After each successful simulation task, the knowledge base is automatically updated according to the following standardized data entry process: First, the central coordinator agent extracts the core data of the entire simulation task. This core data includes the simulation intent, the parsed full set of key simulation parameters, the execution configuration and result data of each stage, the simulation conclusions, and the optimization scheme. Then, it is standardized and cleaned according to the field requirements of the simulation case library. Next, the cleaned case data is compared with existing cases in the simulation case library for similarity. Cases determined to be duplicates are only updated with historical call counts and not added to the database again. Cases determined to be non-duplicates are encoded into vectors, and the structured data is written to a relational database, while the semantic vector is written to a vector database, completing the case entry process. The relational database stores all data in the knowledge base with fixed fields and standardized formats. Each update automatically generates a version number and update log, supporting historical version backtracking. In this embodiment, during automatic knowledge base updates, if the cosine similarity between a new case and a case in the library is ≥0.9, the new case is determined to be a duplicate, and only the historical call count of the corresponding case in the library is updated; it is not added to the database again. When the cosine similarity is less than 0.9, the new case is determined to be a non-duplicate case, and the aforementioned standardized data entry process is executed.

[0061] Furthermore, in this embodiment, all agents within the multi-agent framework adopt a unified and standardized interface system to achieve decoupled design and data interoperability among agents, thereby addressing the shortcomings of existing parallel architectures such as high coupling, inconsistent interfaces, and poor scalability. The specific implementation method is as follows:

[0062] Each agent uses the gRPC protocol for high-frequency real-time interactions such as status feedback and anomaly reporting, and uses the HTTP / HTTPS RESTful API protocol for low-frequency task assignment and result feedback. All interaction data uses a unified JSON format, with messages containing a fixed general message header and an extensible business message body. All fields follow unified naming and data type specifications to ensure system-wide compatibility and parsing. The message header includes: a globally unique message ID, a simulation task ID, sender / receiver agent identifiers, message type, and a timestamp. In other embodiments, regardless of whether the agents are deployed locally or in a distributed manner, they all use the gRPC protocol for high-frequency real-time interactions such as status feedback and anomaly reporting. gRPC not only supports remote procedure calls across devices but is also suitable for communication between multiple processes / services deployed locally.

[0063] Furthermore, this embodiment adopts a standardized request-response model, where only the central coordinator agent has the authority to actively issue tasks, and the remaining agents only respond to instructions and provide feedback on execution status and results. There are no direct calls between the remaining agents, and cross-agent data interactions are all forwarded through the central coordinator. All interface calls are set with timeout thresholds, and timeouts trigger exception handling.

[0064] Furthermore, during single-condition simulation, a fixed state machine flow is followed. The next task is only triggered after the previous task is completed and verified by the central coordinator. The fixed sequence is: geometric preprocessing, mesh generation, simulation solution, result analysis, and report generation.

[0065] For anomaly reporting, the remaining agents report standardized anomaly information to the central coordinator through a unified interface, including anomaly level, anomaly type, occurrence stage, details, execution snapshot, and repairability. Anomaly levels include warning, error, and critical, with corresponding tiered handling rules for different levels, achieving unified anomaly management across the entire process. In this embodiment, the anomaly level classification criteria and corresponding handling rules are as follows: Warning level corresponds to non-critical anomalies that do not affect the normal execution of the process, such as grid quality approaching a threshold. The handling rule is: after an agent reports an anomaly, the central coordinator agent records the anomaly log, the process proceeds normally, and a warning message is simultaneously pushed to the user. Error level corresponds to anomalies that affect the validity of the execution result of the current stage and can be resolved through automated repair, such as substandard grid quality. The handling rule is: the central coordinator agent pauses the process, locks the current state, searches the knowledge base to match a repair solution, issues a repair instruction to the corresponding agent, restarts the current stage after repair, and automatically retryes a maximum of 3 times for a single error. For critical exceptions that prevent the process from continuing and for which there is no automated repair solution, such as error-level exceptions that fail to be repaired three times in a row, the handling rule is as follows: the central coordinator agent immediately terminates the entire process, releases all computing resources, generates an exception termination report, and notifies the user to intervene manually.

[0066] In this embodiment, after receiving user input, the central coordinator agent generates standardized structured tasks according to fixed rules based on the simulation intent and key parameters parsed from the large language model. The generation logic of the structured tasks is as follows:

[0067] The parsed structured key-value pair data, including key parameter identifiers and corresponding key parameter values, is mapped to corresponding modules according to preset fixed module definitions. Default parameters and required fields are completed for different analysis types. Required fields are key parameters and key parameter data that must be included in the user input. After successful validation, a final executable standardized task is generated. If validation fails, the user is automatically prompted for supplementary information, or the knowledge base is searched to match industry-standard default parameters. All tasks consistently include three core modules: a mesh control module, a simulation solution control module, and a result analysis control module. The secondary fields under each module strictly adhere to the preset fixed definitions of this embodiment, as follows:

[0068] The mesh control module includes secondary fields such as global mesh size, cell type, mesh quality threshold, local refinement rules, and geometric feature adaptation rules.

[0069] The simulation solution control module includes secondary fields such as analysis type, material parameter set, load case set, boundary condition set, solver configuration, and convergence control criterion.

[0070] The results analysis control module includes secondary fields such as performance metrics of interest, design allowable values, optimization requirements, and results extraction rules.

[0071] Simultaneously, for different analysis types, the system automatically supplements the corresponding required fields recorded in the user input. After the structured task is generated, the system automatically verifies the completeness of the required fields. If the verification fails, the system automatically sends a request for supplementary information to the user or searches the knowledge base to match industry-standard default parameters.

[0072] For scenarios where users only input material names without specifying parameters, the central coordinator agent uses the parsed material names as search terms to perform a vectorized search in the knowledge base, filling in the default values ​​with the material parameters that meet the similarity criteria and have the highest historical call frequency. For scenarios where users input load types without specifying the application method, the central coordinator agent automatically matches standardized load application strategies that conform to industry standards based on the analysis type and the simulation experience base in the knowledge base.

[0073] For example, the specific steps for parsing user input are as follows:

[0074] When the user inputs natural language including the following: "Use a 5mm tetrahedral mesh", the large language model: DeepSeek-R1 model parses the natural language and obtains the following global mesh parameters: mesh size: 5mm, mesh type: tetrahedral.

[0075] When the user inputs natural language containing the following: "density (g / cm³) = 1.12, elastic modulus (MPa) = 5500, Poisson's ratio = 0.42", the parsing process obtains the material parameters: density (g / cm³) = 1.12, elastic modulus (MPa) = 5500, Poisson's ratio = 0.42.

[0076] When the user inputs natural language including the following: "Apply a force of 500N to the right edge", the parsing results in the following loading conditions: type: force, magnitude: 500, application direction: X, application location: right boundary point.

[0077] When the user inputs natural language including the following: "fixed left edge", the boundary conditions are parsed as follows: type: fixed, location: left boundary point, constraint: [X, Y, Z].

[0078] When the user inputs natural language including the following: "Static analysis", the parsing process obtains the analysis type and analysis items: Static analysis, focusing on displacement and stress.

[0079] Subsequently, the central coordinator agent converts the obtained key parameters into structured tasks, divides these tasks into predetermined modules, and distributes them to the corresponding agents. These modules serve as standardized inputs and the sole basis for each agent to execute its corresponding simulation task. In this embodiment, the predetermined modules include at least a mesh control module, a simulation solution control module, and a result analysis control module. A geometry preprocessing control module and a report generation control module can be added according to user needs. The mesh control module, simulation solution control module, and result analysis control module encapsulate the full execution parameters and control rules for their respective simulation stages, specifically as follows:

[0080] The mesh control module encapsulates all the control parameters required for the mesh generation agent to perform automated mesh generation, including but not limited to global mesh size rules, cell type definitions, local mesh refinement strategies, mesh quality control standards, and geometric feature adaptation rules. The central coordinator agent extracts all the control parameters required for automated mesh generation from the structured task, encapsulates them in this module, and then distributes them to the mesh generation agent.

[0081] The simulation solver control module encapsulates all control parameters required for the simulation solver agent to perform automated simulation calculations, including but not limited to simulation analysis type definitions, material property parameter sets, load case setting rules, boundary constraint definitions, solver configuration parameters, and calculation convergence control criteria. The central coordinator agent extracts all control parameters (material parameters, loads and boundary conditions, analysis commands) required for automated simulation calculations from the structured task, encapsulates them in this module, and then distributes them to the simulation solver agent.

[0082] The results analysis control module encapsulates all the control rules required for the results analysis agent to perform automated results verification and analysis, including but not limited to simulation performance metrics, allowable values ​​for result reasonableness, optimization analysis requirements, and target data extraction rules. The central coordinator agent extracts the performance metrics of interest from the structured task, encapsulates them in this module, and then distributes them to the results analysis agent.

[0083] For example, structured content is illustrated below:

[0084] {"Mesh":{"Size":"5mm","Type":"Tetrahedral","Region":""},"Simulation":{"Analysis Type":"Static","Material Parameters":{"Density":1.12"Elastic Modulus":5500,"Poisson's Ratio":0.42},"Load":[{"Type":"Force","Magnitude":"500N","Application Location":"Right Boundary Point","Application Direction":"X Direction"}],"Boundary Conditions":[{"Type":"Fixed","Location":"Left Boundary Point","Constraint":"[X,Y,Z]"}]},"Results":{"Performance of Interest":["Stress","Displacement"]}}.

[0085] Furthermore, the central coordinator agent incorporates a full-process state monitoring and closed-loop management module to monitor the execution status of each agent in real time, achieving closed-loop management of the entire simulation process and constructing a star-shaped management architecture based on the central coordinator agent, distinct from parallel serial architectures. Specifically, the central coordinator agent creates an independent state machine for each simulation task, containing the following fixed execution states: pending execution, in progress, completed, abnormally paused, and terminated. Each execution stage of each agent corresponds to a sub-state node in the state machine, with specific monitoring rules as follows:

[0086] A real-time status feedback mechanism is implemented. During task execution, each agent sends a heartbeat packet and execution progress feedback to the central coordinator agent at fixed intervals (500ms in this embodiment). The feedback includes the current execution step, execution progress percentage, completed sub-nodes, and current running parameters. Based on the feedback, the central coordinator agent updates the sub-node states of the state machine in real time and synchronously updates the overall execution progress.

[0087] The central coordinator intelligent agent retains all task-issued messages, status feedback messages, data transmission messages, anomaly reporting messages, and execution result data throughout the entire process, storing them in an execution log library bound to the simulation task ID, providing complete data support for subsequent anomaly investigation and process backtracking.

[0088] Furthermore, based on feedback data from each agent, the central coordinator agent determines the execution status of the entire process and each stage according to the following rules:

[0089] Normal execution status determination: When the agent returns normal heartbeat packets and progress feedback within the timeout threshold, the execution progress continues to advance, and no abnormalities are reported, it is determined to be in normal execution status, and the state machine is marked as: Executing.

[0090] When the agent returns a task completion receipt and a compliant execution result, and the execution result passes the preset compliance check of the central coordinator agent, the process is considered complete. The corresponding child node of the state machine is marked as "completed", and the task of the next process is automatically triggered.

[0091] Abnormal pause state determination: When the agent reports an error-level abnormality or fails to return a heartbeat packet and feedback data beyond the timeout threshold, it is determined to be an abnormal state. The state machine immediately marks it as: abnormal pause, suspending the issuance and execution of all tasks in the entire process, and locking the current execution state and data snapshot.

[0092] When a process terminates, if the agent reports a fatal exception or the automated repair mechanism fails to resolve the exception, the process is deemed unable to continue. The state machine is marked as terminated, a process termination report is generated, and engineers are notified to intervene.

[0093] Based on the state machine's decision-making results, the central coordinator agent issues the following control commands to each agent to achieve closed-loop control throughout the entire process. Specifically, these include:

[0094] Once the process is proceeding normally, and the completion status of a step is verified, a task execution instruction is sent to the next intelligent agent to advance the process.

[0095] When an abnormal pause state is detected, a pause command is sent to all agents currently executing tasks to lock the current execution state and prevent the abnormality from spreading.

[0096] The process rollback instruction, when the root cause of an anomaly is located to a parameter or execution defect in a preceding stage, issues a rollback modification instruction to the corresponding agent, reverting the process to that stage for re-execution, without needing to restart the entire process from the initial stage. In this embodiment, the root cause location is uniformly executed by the central coordinator agent, and the specific implementation process is as follows:

[0097] Anomaly Information Extraction: When an agent reports an anomaly or a process is triggered to pause due to an anomaly, the central coordinator agent extracts the anomaly type, the stage in which it occurred, error logs, execution snapshots, and full-process state machine data to generate standardized anomaly feature text.

[0098] Root cause matching retrieval: Using standardized abnormal feature text as search terms, vectorized retrieval is performed in the error diagnosis pattern library and simulation experience library of the knowledge base to match the root cause localization logic and historical abnormal cases corresponding to the abnormality, and to initially locate the root cause and root cause of the abnormality.

[0099] Full-link backtracking verification: If there is no matching knowledge base content, the central coordinator agent starts from the point where the anomaly occurred and backtracks along the simulation process in reverse, verifying the compliance of the execution results of each preceding step, the rationality of the parameters, and the accuracy of data transmission in turn, eliminating non-root cause steps one by one, and finally locating the root cause step and defect type of the anomaly.

[0100] Root cause identification: After locating the root cause, the central coordinator agent verifies the input parameters, execution process, and output results of that step to determine whether the root cause is a defect in parameter settings, an operational defect, or a data transmission defect, thus completing the anomaly root cause localization.

[0101] The process restart command is issued to the corresponding intelligent agent after the anomaly is repaired, so that the process can continue to be executed from the paused node.

[0102] When a process is determined to be unable to continue execution, a termination command is issued to all agents to terminate all execution processes of the current task and release computing resources.

[0103] Furthermore, the central coordinator agent pre-sets compliance verification rules for the execution results of each stage. These rules are derived from simulation experience bases and practice guidelines in the knowledge base. For example, the verification rules for the geometry preprocessing stage are: the geometric model must be closed, with no free edges and no repeating surfaces. If the verification fails, automatic geometry repair is triggered, and if repair fails, an error-level anomaly is reported. The verification rules for the mesh generation stage are: the mesh quality index must reach a preset threshold and there must be no negative Jacobian elements. If the verification fails, local mesh reconstruction is triggered, and if reconstruction fails, an error-level anomaly is reported.

[0104] The compliance verification in the simulation solution process is divided into two layers: file integrity verification and physical rationality verification, which are performed sequentially.

[0105] The first layer of file integrity verification verifies that the h3d result file output by the solver exists and its size is not zero. At the same time, it verifies that the result file contains all the performance indicators of interest specified by the user, such as displacement, stress, safety factor and other valid data nodes. If any one of them is missing, the file is judged to be incomplete and the solution is retried.

[0106] The second layer of physical rationality verification involves the result analysis agent extracting the global maximum stress value and the global maximum displacement value from the h3d file. If the global maximum stress value exceeds 5 times the material yield strength, or the global maximum displacement value exceeds 50% of the model feature size, it is determined to be a numerical divergence rather than a true physical result. At the same time, the solver convergence log is read to verify whether the residual of the final iteration step meets the preset convergence threshold. In this embodiment, the static analysis convergence threshold is set to relative residual ≤ 1e-6. If the residual exceeds the threshold, it is determined to be non-converged.

[0107] After both layers of verification pass, the corresponding child node of the state machine is marked as completed, and the task of the result analysis stage is automatically triggered. If any layer of verification fails, an error-level exception is reported to the central coordinator agent, triggering the preset automatic repair mechanism. The execution result of each stage must pass the compliance verification before it can enter the next stage, so as to avoid the defects of the previous stage from being transmitted to the subsequent stage and causing cross-stage chain exceptions.

[0108] In this embodiment, the central coordinator intelligent agent has three built-in scheduling and control modules, including a single-condition full-process serial scheduling module, a multi-condition parallel scheduling module, and a multi-physics field coupled collaborative control module.

[0109] Among them, such as Figure 2 As shown, the single-condition full-process serial scheduling module is used for full-process timing control and task scheduling in single-condition simulation scenarios. It is the basic core scheduling module of the central coordinator intelligent agent. It is used to realize end-to-end full-process serial timing control, task issuance scheduling, link access control and data flow control in single-condition simulation scenarios. It is the underlying foundation for multi-condition parallel scheduling and multi-physical field coupled control.

[0110] The specific execution rules of the single-condition full-process serial scheduling module are as follows:

[0111] The simulation process follows a fixed sequence: geometric preprocessing, mesh generation, simulation solving, result analysis, and report generation are assigned tasks in sequence. If a preceding step fails the compliance check, the subsequent steps must not be started.

[0112] The state machine is updated in conjunction with the full-process status monitoring and closed-loop management module to achieve closed-loop process management;

[0113] All cross-process data is uniformly transferred through the single-condition full-process serial scheduling module, and there is no direct data transmission between the various executing intelligent agents.

[0114] The central coordinator intelligent agent, through its built-in multi-condition parallel scheduling module and multi-physics field coupled collaborative management module, achieves intelligent scheduling of multi-task parallel processing and multi-physics field coupled analysis in complex industrial scenarios. The specific implementation method is as follows:

[0115] like Figure 3 As shown, when the user input includes multiple parallel simulation conditions, such as multiple load conditions, multiple material parameter comparison conditions, and multiple boundary condition verification conditions for the same model, the central coordinator agent executes the following task decomposition and scheduling process:

[0116] The process involves splitting the work conditions and constructing a task tree. Based on the parsed user input, the central coordinator agent identifies the common and unique parameters of the parallel work conditions. It merges common execution steps such as geometry preprocessing and mesh generation into a common parent task, and splits the unique execution steps of each work condition, such as simulation solving and result analysis, into parallel sub-tasks, thus constructing a tree-shaped task structure of common parent task and parallel sub-tasks.

[0117] Task priority configuration: The central coordinator agent assigns multiple priority levels (e.g., 1-10) to each parallel subtask based on the user-inputted task priority and urgency. Lower priority numbers indicate higher execution priority. The initial default is the median priority of all tasks, such as level 5. Users can specify priorities via natural language. Furthermore, if no priority is specified by the user, the priority is automatically adjusted based on the estimated computational workload of each task, assuming a default priority of 5. Tasks with estimated computational workload exceeding twice the average workload of a single task are automatically prioritized by one level. In this embodiment, tasks with priorities of 1-3 preferentially utilize dedicated CPU cores and memory resources, tasks with priorities of 4-7 share remaining resources, and tasks with priorities of 8-10 are executed only when resources are available.

[0118] Parallel task resource allocation and execution control: The central coordinator agent allocates corresponding computing resources to subtasks of different priorities based on server hardware resources. Subtasks with higher priorities occupy resources first. The number of subtasks that can be executed in parallel at the same time is dynamically adjusted according to the hardware resource threshold to avoid resource overload.

[0119] Furthermore, when multiple parallel subtasks encounter resource contention or data read / write conflicts, the central coordinator agent resolves the conflicts according to the rule of "highest priority first, first-come-first-served." For conflicting tasks with the same priority, resources are allocated using a time-slice round-robin method to ensure that all tasks can be executed in an orderly manner.

[0120] In the multi-condition parallel scheduling process, before the common parent task is completed and the parallel subtasks are issued, a multi-condition baseline consistency mandatory control is performed. The specific implementation method is as follows: after the common parent task is completed, a baseline model with a unique identifier is generated. The baseline model includes a baseline geometric model and a baseline mesh model. All geometric features, mesh parameters, and quality standards of the baseline model are locked, and any modification by any parallel subtask is prohibited.

[0121] When all parallel subtasks are issued, only individual parameters are attached. These individual parameters are three categories: load parameters, material parameters, and boundary condition parameters, which differ between different working conditions. Parallel subtasks must directly call the locked reference model and are prohibited from modifying the reference geometry and reference mesh.

[0122] The knowledge base pre-stores solution convergence criterion rule templates and result extraction rule templates for different analysis types, element types, mesh quality levels, and solver configuration scenarios. After the central coordinator agent generates the baseline geometric model and baseline mesh model in the common parent task, it extracts the model features and analysis features of the baseline geometric model and baseline mesh model. The model features and analysis features include at least one or more of the following: analysis type, element type, mesh quality level, and solver type.

[0123] The central coordinator agent uses the model features and analysis features as retrieval conditions to match the corresponding solution convergence criteria and result extraction rules from the knowledge base, and uniformly distributes them to all parallel subtasks for execution, thereby ensuring that the simulation results of all working conditions are only affected by individual parameters and have strict horizontal comparability.

[0124] Among them, the geometric model refers to the CAD geometric solid model of the object to be analyzed used in finite element preprocessing. It contains geometric topology information such as solids, surfaces, edges, and points. It can be represented by STEP format files or other CAD model format files and serves as the input basis for geometric inspection, repair, feature simplification, and subsequent mesh generation.

[0125] A mesh model refers to a finite element discrete model formed by meshing the geometric model. It includes nodes, elements, element types, mesh size, local refinement information, and quality control parameters, and corresponds to the FEM mesh file that the solver can call.

[0126] A baseline model refers to a unified basic model formed and locked after the execution of a common parent task in a multi-condition parallel simulation scenario. It includes at least a baseline geometric model and a baseline mesh model, which are used to provide a consistent geometric and mesh basis for each parallel subtask to ensure the horizontal comparability of simulation results under different conditions.

[0127] The specific implementation method of cross-condition collaborative optimization is as follows: after all parallel subtasks are completed, the multi-condition parallel scheduling module carried by the central coordinator agent automatically extracts key performance indicators such as stress, displacement, and safety factor for all conditions.

[0128] With the constraint that the performance indicators of all working conditions meet the design allowable values, and with the optimization objectives of lightweight structure and optimal performance, the optimization variables are the fillet radius, wall thickness, and material parameters of the structure. Based on the key performance indicators such as stress, displacement, and safety factor automatically extracted after the execution of all parallel subtasks, a Kriging surrogate model is constructed. The global optimization is completed by the NSGA-III multi-objective optimization algorithm to obtain the Pareto optimal solution set. The Pareto optimal solution set is the non-dominated solution set of multi-objective optimization, which covers all optimal solutions that take into account all optimization objectives. It is used to provide users with a multi-dimensional set of optional solutions and solve the problem of conflict between multiple optimization objectives.

[0129] Before entering the proxy model construction phase, the central coordinator agent first automatically identifies the number of optimization variables, *d*. The range of values ​​for each optimization variable serves as the boundary of the design space, with the upper and lower bounds determined by user input or industry design specifications matched in the knowledge base. Using the Latin hypercube sampling method, N supplementary sampling points are automatically generated within this design space. The calculation rule for N is 10 times the dimension *d* of the design variables, i.e., N = 10d. The central coordinator agent encapsulates the combination of optimization variable parameters corresponding to each supplementary sampling point into an independent verification simulation subtask. It reuses the baseline model generated by the common parent task and batch-drives the geometry preprocessing agent, mesh generation agent, and simulation solving agent to sequentially complete the corresponding simulation calculations. The key performance indicators obtained from the supplementary simulation are then merged with the simulation results of the original parallel operating conditions. Among them, the simulation results of the original parallel working conditions use the benchmark geometric parameter values ​​generated by the common parent task as the coordinates of the geometric optimization variable dimension. Together with the load, material, and boundary condition parameters of each working condition, they constitute the input feature vector of the sample points. Thus, they are uniformly expressed in the same design space coordinate system as the supplementary sampling points, and together they constitute the training sample set of the proxy model, forming a full training sample set covering no less than N+ working conditions and several sample points in the design space.

[0130] Users specify the relative priorities of each optimization objective via natural language. The central coordinator agent parses this into weight vectors corresponding to each optimization objective based on a large language model. It then uses a weighted ideal point method to comprehensively score each scheme in the Pareto optimal solution set, outputting the scheme with the highest comprehensive score as the optimal solution. After selecting the optimal solution from the Pareto optimal solution set based on the user-input optimization priorities, the system automatically sends verification tasks containing the structural geometric parameters and material parameters corresponding to the optimal solution to the geometry preprocessing agent, mesh generation agent, and simulation solving agent. Upon completion of verification, it outputs the optimal structural scheme, a multi-condition comparison report, and the verification results.

[0131] After all parallel subtasks are completed, the central coordinator agent automatically summarizes the simulation results of all operating conditions and sends them to the result analysis agent for multi-operating condition comparison analysis. Finally, the report generation agent generates a multi-operating condition comparison simulation report.

[0132] Multi-physics coupling analysis is implemented based on a multi-physics coupling collaborative management and control module. The multi-agent collaborative execution logic is as follows: When the user input is multi-physics coupling analysis, such as thermal-structural coupling, fluid-structure coupling, or electromagnetic-thermal coupling, the central coordinator agent executes the following collaborative scheduling logic:

[0133] After parsing the coupling analysis type from the natural language description input by the user based on a large language model, the central coordinator agent completes the physical field decomposition, subtask creation, and execution sequence planning according to the following steps:

[0134] Step S1: Identify the number and type of physical fields involved in the coupling based on the coupling analysis type, and create a simulation solution subtask for each independent physical field;

[0135] When the coupling analysis type is thermal-structural coupling, two physical fields, thermal field and structural field, are identified, and corresponding thermal field analysis subtasks and structural field analysis subtasks are created.

[0136] Step S2: Identify the data transfer direction between physical fields based on user input and the rule templates of the corresponding coupling type in the knowledge base.

[0137] If the calculation result of the source physics field is used as the input boundary condition of the target physics field, and there is no feedback of the result from the target physics field back to the source physics field, then it is determined to be a one-way coupling.

[0138] If there is bidirectional result feedback between two physical fields and iterative updates are required, then it is determined to be bidirectional coupling.

[0139] Step S3: When it is determined to be unidirectional coupling, the central coordinator agent plans to execute asynchronously and serially according to the rule that the source physical field subtask is executed first and the target physical field subtask is executed later.

[0140] The next subtask is only triggered after the previous subtask is completed and a transferable field result is formed.

[0141] When bidirectional coupling is determined, the central coordinator agent plans each physical field subtask to be executed synchronously and iteratively, and determines whether to continue iterating according to the preset convergence threshold.

[0142] For example, in a one-way coupling analysis of thermal and structural fields, the central coordinator agent identifies the thermal field results as inputs to the structural field loads, and there is no feedback path for the structural field results to correct the thermal field results. Therefore, two subtasks are created: a thermal field analysis subtask and a structural field analysis subtask, and they are planned to be executed asynchronously and sequentially, with the thermal field preceding the structural field.

[0143] For the thermal-structural bidirectional coupling analysis, the central coordinator agent identifies the bidirectional data feedback between the thermal field and the structural field. Therefore, it creates two parallel iterative subtasks: a thermal field analysis subtask and a structural field analysis subtask, and plans to execute them synchronously.

[0144] The central coordinator agent creates independent simulation subtasks for each physics analysis, assigns corresponding solver configuration parameters to each subtask, and manages the execution, start / stop, and data transfer of each subtask. For bidirectional coupled analysis, the central coordinator agent monitors the iterative convergence status of the two physics subtasks in real time. When the calculation results of all physics fields reach the convergence threshold or the maximum number of iterations is reached, the coupled iteration process is terminated. In this embodiment, the convergence threshold for bidirectional coupled analysis is set as follows: the relative residual of key result variables between adjacent iteration steps ≤ 1e-3. Key result variables include the average temperature, average displacement, and maximum equivalent stress of the coupled region.

[0145] The transfer of result data between different physics subtasks is standardized and forwarded through a central coordinator agent to map the source physics results to the input boundary conditions of the target physics. In this embodiment, the mapping rule for physics result data transfer is as follows: an interpolation algorithm based on element shape functions is used to map the nodal results of the source physics to the grid nodes of the target physics. Data conservation is ensured during the mapping process, and the interpolation error threshold is set to ≤1%. This mapping rule ensures that the calculation results of the source physics can be accurately mapped to the input boundary conditions of the target physics, thus solving the data incompatibility problem in multiphysics coupling analysis.

[0146] When one of the physical field subtasks malfunctions, the central coordinator agent automatically suspends all associated coupled field subtasks, triggers the anomaly repair mechanism, and automatically restarts the coupling analysis process from the iteration step where the anomaly was interrupted, without having to re-execute the entire process calculation.

[0147] In this embodiment, the geometry preprocessing agent provides two standardized functional interfaces: a geometry preprocessing task execution interface and a geometry model secondary modification interface. The geometry preprocessing task execution interface receives the geometry model file and geometry processing rule parameters from the central coordinator agent, performs model import, geometry checks, repairs, and simplifications, and returns the processed geometry model file, processing result status, and geometry quality verification report. The geometry model secondary modification interface receives repair / modification instructions from the central coordinator agent, performs targeted modifications to the geometry model, and returns the modified geometry model and a modification result report.

[0148] The geometry preprocessing agent receives the geometric model file and geometric processing rule parameters from the central coordinator agent, completes the preprocessing operations of the geometric model, and outputs the processed geometric model. In this embodiment, the geometry preprocessing agent uses the API interface provided by the finite element analysis preprocessing software HyperMesh to complete functions such as model import and inspection, geometry repair, and feature simplification.

[0149] Specifically, the geometry preprocessing agent is associated with the HyperMesh API interface. It calls the HyperMesh API interface using the built-in Python language, configures the corresponding Python environment, and calls key API functions for model import and geometry checking, geometry cleaning and repair to implement the functionality. The specific steps are as follows:

[0150] Model import and geometry check: Set the OptiStruct solver template, import STEP format files issued by the central coordinator agent or provided by the user, or other CAD models, and complete the preliminary check of model integrity and geometric defects.

[0151] Geometric cleanup and repair involves fixing detected geometric defects, eliminating unnecessary free edges and duplicate faces, and verifying the closure and integrity of the geometric model. If incomplete, a secondary repair is performed; if the repair fails, an error-level anomaly is reported to the central coordinator agent, providing a qualified geometric basis for subsequent mesh generation.

[0152] Furthermore, during the geometric cleanup and repair process, the following defects were identified: free edges, non-coincident edges, T-connections, duplicate surfaces, and holes / gaps. For free edges, the automatic stitching function was used for repair, with the stitching tolerance set to one-tenth of the global mesh size. For non-coincident edges, automatic alignment and stitching were used for repair. For T-connections, missing surfaces were automatically identified and filled to ensure solid continuity. Duplicate surfaces and redundant geometry were automatically deleted. Non-closed gaps were automatically filled to ensure that the final model is a fully closed solid geometry.

[0153] The mesh generation agent provides two standardized functional interfaces: an automated mesh generation interface and a local mesh optimization interface. The automated mesh generation interface receives the processed geometric model and mesh parameters from the central coordinator agent, performs mesh generation and quality verification, and outputs an FEM mesh file that meets the solver's requirements, a mesh quality report, and execution status results. The local mesh optimization interface receives mesh optimization instructions from the central coordinator agent, refines / coarses / reconstructs the mesh in a specified region, and returns the optimized mesh file and a quality verification report.

[0154] The mesh generation agent receives the geometric model issued by the central coordinator agent, which has been completed and verified by the geometry preprocessing agent, and the global mesh parameters obtained by the central coordinator agent from parsing user input. It then calls the relevant API interfaces of the HyperMesh batchmesh function module to generate the mesh.

[0155] Specifically, the mesh-generating agent receives structured output from the central coordinator agent and uses Python to call the API interfaces of the batchmesh module provided by HyperMesh to generate the mesh. The specific implementation process is as follows:

[0156] Environment and parameter initialization are performed using a Python script. The Python script reads a predefined parameter dictionary, which defines key information such as global mesh size, local refinement regions, and element types (e.g., tetrahedron, hexahedron). Based on these parameters, the Python script dynamically generates two core configuration files required to call the batchmesh module: a Criteria File and a Parameter File. The fixed mapping rules from mesh parameters to configuration files are as follows: global mesh size, element type, and quality threshold are mapped to the ELEMENT_SIZE, ELEMENT_TYPE, and QUALITY_CRITERIA fields in the Criteria File; local refinement rules and geometric feature processing rules are mapped to the REFINEMENT_CONTROL and GEOMETRY_PROCESSING fields in the Parameter File; and adaptive refinement rules for thin-walled and high-curvature regions are mapped to the SIZE_CONTROL field in the Criteria File.

[0157] Automated mesh generation: The batchmesh module, driven by Python scripts, automatically processes the geometric model. The workflow includes:

[0158] Import the qualified geometric model file issued by the central coordinator agent, perform mesh generation based on the Criteria File and Parameter File, and generate the basic mesh;

[0159] By further integrating the Size Field function through the Python API, a smooth transition of mesh size from critical areas to regular areas can be achieved, thereby improving mesh quality and obtaining the final mesh.

[0160] After the mesh is generated, the Python script calls the built-in quality check tool of the batchmesh module to automatically verify the mesh quality and ensure that element indicators, such as the Jacobian determinant, meet the solver's requirements. Finally, the Python script exports the generated mesh as an FEM mesh file supported by the OptiStruct solver.

[0161] Furthermore, the mesh-generating agent in this embodiment also has the following technical implementation details:

[0162] Based on global mesh size control, an adaptive refinement strategy is adopted: automatically identifying three key features in the model: thin-walled regions, high-curvature regions, and structural junction regions. Thin-walled regions are defined as those where the ratio of local wall thickness to global mesh size is no greater than 2; high-curvature regions are defined as those where the radius of curvature of the surface is less than twice the global mesh size; and structural junction regions are defined as the connection surfaces and weld areas of two or more entities. The identified key regions are automatically refined to half to a quarter of the global mesh size. For thin-walled regions, at least two layers of elements are ensured along the wall thickness direction; for high-curvature regions, at least three layers are ensured along the curvature direction. Simultaneously, three to five transition layers of elements are set between the refined and regular regions to avoid abrupt changes in mesh size and ensure sufficient resolution in the key regions.

[0163] After mesh generation, a dual quality and stability check is performed according to industry-standard criteria: The focus is on checking the positive value of the Jacobian determinant and the integrity of the topological structure, ensuring that all elements have a positive Jacobian determinant value, verifying the existence of simply connected domains, and confirming the integrity of boundary closure. Specific quality thresholds are also set for different element types. Elements that fail the check are automatically refactored locally until all elements meet the threshold requirements, fundamentally guaranteeing the numerical computational stability of thin-walled geometries.

[0164] For the two core configuration files required for mesh generation, the Criteria File and Parameter File, the Python script automatically generates them according to fixed mapping rules based on the mesh parameters and geometric model features issued by the central coordinator. The Criteria File generates corresponding control fields based on global mesh parameters, element type, quality verification standards, and adaptive refinement rules, while the Parameter File generates corresponding control fields based on feature simplification thresholds and geometric feature processing rules, ensuring that the configuration files are completely matched with the mesh generation requirements.

[0165] The simulation solver agent provides two standardized functional interfaces: a simulation solver execution interface and a solver parameter secondary adjustment interface. The simulation solver execution interface receives the FEM mesh file, solver parameters, material parameters, loads, and boundary conditions from the central coordinator agent, constructs the solver input file, executes the solver, monitors the process, and returns the solution result h3d file, solver log, and execution status results. The solver parameter secondary adjustment interface receives parameter modification commands from the central coordinator agent, updates the solver configuration, re-executes the solver, and returns the new solver results and execution report.

[0166] The simulation solver agent receives the FEM mesh file generated and verified by the mesh generation agent from the central coordinator agent, as well as all parameters of the simulation solver control module from the central coordinator agent, configures and calls the commercial software OptiStruct solver to perform the solution.

[0167] The specific implementation method is as follows:

[0168] Solver Input Construction: The simulation solver agent runs as an independent module, receiving structured output from the central coordinator agent, obtaining the analysis type, material parameters, loads and boundary conditions, and sequentially completing material creation and assignment, load and constraint application, analysis case definition, and FEM mesh file update based on the FEM mesh file issued by the central coordinator agent, finally generating a file that conforms to the OptiStruct solver input standard.

[0169] Solving and Exception Handling: The Python script executes the OptiStruct solver commands through the operating system's command-line interface (e.g., using the subprocess module), specifying the FEM mesh file generated in the previous step as input. The Python script monitors the output log (.out file) of the solving process in real time, capturing the solution status, iteration information, or potential errors and warnings to ensure smooth computation.

[0170] If an error occurs during the solution process, standardized anomaly information is immediately reported to the central coordinator agent, triggering an intelligent recovery mechanism: the central coordinator agent searches the simulation case library and error diagnosis pattern library in the knowledge base to attempt to match known solutions; if no matching known solution is found, the central coordinator agent drives its built-in large language model to analyze error logs and full-process context parameters to generate a repair strategy; engineers are only notified to intervene when all automated methods fail. After the solution is completed, OptiStruct outputs an h3d format result file.

[0171] The simulation solving agent, based on all parameters of the simulation solving control module issued by the central coordinator, automatically updates and constructs the FEM mesh file according to fixed mapping rules. All parameters are mapped to standard card formats compatible with the OptiStruct solver. Material parameters are mapped to corresponding linear material cards and thermal material cards according to their type. Loads and constraints are mapped to corresponding standard cards for force, torque, heat flux density, fixed constraints, and degree of freedom constraints according to their type. Analysis cases generate corresponding static, modal, and multiphysics coupling analysis control cards according to the analysis type. All generated cards are automatically written into the FEM mesh file output by the mesh generation agent, overwriting the original default configuration and generating the final input file that meets the solver requirements.

[0172] For errors captured during the solution process, automated recovery is performed according to a fixed procedure:

[0173] The simulation solving agent first extracts error keywords, error codes, occurrence locations, and error contexts from the solver's output log file, generating standardized error feature text, which is then reported to the central coordinating agent. The central coordinating agent uses this text as a search term to perform a vectorized search in the error diagnosis pattern library of the knowledge base, matching error patterns with matching similarity criteria and corresponding standardized repair solutions. Based on the repair solution, it issues repair instructions to the corresponding stage agents. After repair, the solving process is automatically re-executed to verify whether the error has been eliminated. A single error type can be automatically retried up to 3 times. If no matching error pattern is found or automatic retry fails, the central coordinating agent inputs the error log and full-process context parameters into its DeepSeek-R1 model. A workable repair solution is generated through fixed constraints and automatically retried. If all automated methods fail, the simulation solving agent reports a fatal anomaly to the central coordinating agent, terminating the process and notifying engineers to intervene.

[0174] The results analysis agent provides two standardized functional interfaces: an automated simulation results analysis interface and a secondary results verification interface. The automated simulation results analysis interface receives the solution result h3d file, performance indicators, and design allowable values ​​from the central coordinator agent, extracts key results, determines their reasonableness, generates optimization suggestions, and returns an analysis report, key indicator data, and optimization recommendations. The secondary results verification interface receives re-analysis commands from the central coordinator agent, performs secondary analysis and verification on the updated solution results, and returns a new analysis report.

[0175] The results analysis agent receives the solution results, automatically extracts key results (such as maximum stress, displacement, and safety factor), and performs compliance checks on the key results based on the verification rules and design allowable values ​​from the simulation experience base issued by the central coordinator agent. It then outputs the judgment results and optimization suggestions. For example, it determines whether the stress exceeds the material's yield strength; if so, it provides optimization suggestions based on the simulation experience base.

[0176] The specific implementation method is as follows:

[0177] The results analysis agent receives structured output from the central coordinator agent, obtains user-specified performance indicators (such as displacement and stress), receives h3d files from the central coordinator agent and provided by the simulation solution agent, and performs secondary development based on the HyperWorks interface to read the result data in the h3d file and extract the performance result data of interest.

[0178] Results analysis and optimization suggestion generation: The extracted performance results data are compared with the preset design allowable values ​​to determine whether the performance indicators of interest are reasonable. The design allowable values ​​are derived from material properties (such as the yield strength of the material) and product design functional requirements (such as the maximum allowable deformation).

[0179] If the judgment result is deemed unreasonable, the simulation experience base in the knowledge base is queried to generate preliminary improvement suggestions. For example:

[0180] If the displacement is determined to be too large, it is recommended to optimize the material distribution, adjust the structural support form, or increase the material stiffness within the structural design domain.

[0181] If the stress is determined to be excessive, it is recommended to fine-tune the geometry of high-stress areas (such as hole edges and fillets) to smooth the stress distribution and reduce stress concentration by changing the contour.

[0182] Specifically, the automated matching of design allowable values ​​is completed by the central coordinator agent: the central coordinator agent uses material name, analysis type, and industry field as search terms to perform vectorized searches in the simulation experience base of the knowledge base, matches the corresponding design allowable values, and sends them to the result analysis agent. Specifically, the stress allowable value matches the material's yield strength, the safety factor uses a common value based on the industry field, the displacement allowable value matches the design specifications of the corresponding industry, and the fatigue life allowable value matches the cycle count requirements of the corresponding working condition. Based on the design allowable values ​​sent by the central coordinator agent, the result analysis agent completes the result rationality judgment.

[0183] The extracted key results are then compared with the matched design allowable values. If all indicators meet the allowable value requirements, the simulation results are considered reasonable. If any indicator exceeds the limit, the results are considered unreasonable, triggering the optimization suggestion generation process.

[0184] For results deemed unreasonable, the result analysis agent reports the abnormal data to the central coordinator agent. The central coordinator agent then matches the corresponding optimization strategy from the simulation experience base and sends it to the result analysis agent, which generates standardized optimization suggestions. Specifically, for stress exceeding limits, suggestions are provided based on the location of high-stress areas, including optimizing geometric features, adjusting local structures, and optimizing material distribution. For excessive displacement, suggestions are provided to adjust material parameters, optimize structural supports, and adjust load application positions. For results anomalies caused by mesh quality, suggestions are provided for mesh refinement and optimization. For resonance risks, suggestions are provided for optimizing structural stiffness and mass distribution. All optimization suggestions are simultaneously annotated with the corresponding knowledge base case source and historical optimization success rate.

[0185] The report generation agent provides a standardized functional interface, namely the simulation report automated generation interface. This interface receives full-process simulation data and report template requirements from the central coordinator agent, generates the report content, formats it, and returns the final PDF / Word format simulation report and execution status results.

[0186] The report generation agent receives standardized data from the entire simulation process, which is aggregated and distributed by the central coordinator agent. This data includes simulation requirement descriptions, processed geometric model information, mesh files and quality reports, solution result files, result analysis data and optimization suggestions. Based on a preset template, the agent integrates and outputs the simulation report. The report text content is generated by the central coordinator agent using its built-in large language model.

[0187] The specific implementation method is as follows:

[0188] Report template construction: The simulation report template used in this embodiment includes the following fixed sections: Project Summary, Introduction and Problem Description, Simulation Model and Method, Results and Analysis, Conclusion and Recommendations.

[0189] Report generation: The report generation agent receives the report generation control instructions, preset report templates, and standardized simulation data issued by the central coordinator agent. It then inputs these data, along with the constructed report templates, into the central coordinator agent's large language model. Utilizing the large language model's text generation capabilities, it outputs a complete and standardized final simulation report.

[0190] Based on the knowledge base and multi-agent framework described above, the process of performing single-condition end-to-end finite element simulation using the multi-agent collaborative end-to-end finite element analysis system proposed in this invention is as follows:

[0191] Step A1: Task Initiation and System Initialization. The central coordinator agent receives the user's input of natural language simulation requirements and corresponding geometric model files, generates a globally unique task ID for this task, initializes the full-process state machine, confirms the connectivity of each agent's interface and the readiness of computing resources, starts the simulation process, and simultaneously creates a dedicated full-link execution log library for this task.

[0192] Step A2: Intent Parsing and Structured Task Generation. The central coordinator agent invokes a domain-fine-tuned large language model to parse the user's simulation intent and extract key parameters. Using these extracted key parameters as search terms, it accesses the knowledge base to complete the standardized completion of missing key parameters and validate required fields. If validation fails, it automatically prompts the user for supplementary information. After successful validation, it generates a structured task that conforms to preset specifications, breaks it down into standardized control modules corresponding to each simulation stage, and completes the task distribution preparation.

[0193] Step A3: Collaborative Execution and Compliance Control in the Pre-processing Stage. Through a unified standardized interface, each agent independently completes its corresponding task and then reports the execution result back to the central coordinator agent. The specific process is as follows:

[0194] The geometric preprocessing agent is given geometric preprocessing task instructions and corresponding control parameters. After completing the corresponding task, the geometric preprocessing agent feeds back the execution results and the processed geometric model to the central coordinator agent.

[0195] The central coordinator agent completes the process verification based on the preset compliance verification rules. After the verification is passed, the full-process state machine is updated, and then the grid generation agent is issued a grid generation task instruction, a qualified geometric model and corresponding control parameters. After the grid generation agent completes the corresponding task, it feeds back the execution result and the generated grid file to the central coordinator agent.

[0196] The central coordinator intelligent agent completes compliance verification and updates the state machine. Only after the previous step passes verification will the next step's task be issued, ensuring that defects in the preceding step are not passed on to the next.

[0197] Step A4: Simulation solution execution and full-process status monitoring.

[0198] After the mesh generation process passes verification, the central coordinator agent sends the solution task instructions, compliant mesh file and solution control parameters to the simulation solution agent.

[0199] The simulation solver agent completes the construction of the solver input file and the simulation calculation. The central coordinator agent monitors the solution progress, convergence status and abnormal situations in real time, completes the abnormal closed-loop handling according to preset rules, and verifies the integrity of the result file after the solution is completed.

[0200] Step A5: Result Analysis and Simulation Report Output. After the solution is completed, the central coordinator agent sequentially issues corresponding task instructions to the result analysis agent and the report generation agent. The result analysis agent completes the extraction of key performance indicators, the determination of the reasonableness of the results, and the generation of optimization suggestions. The report generation agent integrates the simulation data of the entire process, generates a standardized simulation report, and outputs it to the user. The central coordinator agent marks the entire process state machine as completed.

[0201] Step A6: Data Archiving and Knowledge Base Update. The central coordinator agent completes the standardized archiving of all data for this task, storing all process messages, execution logs, simulation data, and result files into the corresponding task's execution log database. Simultaneously, it extracts the core data from the entire simulation task and, according to preset deduplication rules and a standardized data entry process, automatically updates the knowledge base, thus completing the closed-loop process of this single-condition simulation.

[0202] Furthermore, based on the aforementioned knowledge base and multi-agent framework, the process of performing multi-condition end-to-end finite element simulation using the multi-agent collaborative end-to-end finite element analysis system proposed in this invention is as follows:

[0203] Step B1: Multi-condition task initiation and system initialization. The central coordinator agent receives the user's input of multi-condition simulation requirements and corresponding baseline geometric model files, clarifies the differentiated parameters, global constraints, and optimization requirements for each condition, generates a globally unique master task ID and independent sub-task IDs for each condition, initializes the multi-condition full-process state machine, and starts the process after confirming that the resources of each distributed computing node and agent are ready.

[0204] Step B2: Multi-condition Intent Parsing and Parameter Decomposition. The central coordinator agent invokes the domain fine-tuning language model to parse the global simulation intent and optimization objectives, identify and decompose the common and individual parameters of all parallel conditions. Among them, the parameters corresponding to geometry preprocessing and mesh generation are identified as global common parameters, and the load parameters, material parameters, and boundary condition parameters that differ between different conditions are identified as independent individual parameters for each condition. Combined with the knowledge base, the standardization and compliance verification of all parameters are completed, forming a global common parameter set and an independent individual parameter set for each condition.

[0205] Step B3: Construction of tree-shaped task structure and mandatory control of baseline consistency.

[0206] The central coordinator intelligent agent has a built-in multi-condition parallel scheduling module that constructs a tree-shaped task structure including a common parent task and parallel sub-tasks based on the parameter decomposition results. It merges common execution links such as geometry preprocessing and mesh generation into a common parent task, and splits individual execution links of each condition such as simulation solving and result analysis into parallel sub-tasks, and allocates execution priority and computing resources to each sub-task.

[0207] The central coordinator agent first executes the common parent task, sequentially completing the baseline geometry preprocessing and baseline mesh generation. Each step performs compliance verification and updates the state machine, generating a baseline geometry model and baseline mesh model with unique identifiers and implementing read-only locking. It enforces preset multi-condition baseline consistency control rules: all parallel subtasks must be executed based on this unique baseline model, and can only modify three types of individual parameters: load, material, and boundary conditions. Subtasks are prohibited from modifying the baseline geometry and baseline mesh. The unified solution convergence criteria and result extraction rules are determined by the central coordinator agent after the baseline model is generated, based on the characteristics of the baseline geometry model and baseline mesh model, by matching from the knowledge base. All parallel subtasks execute unified mesh quality standards, solution convergence criteria, and result extraction rules, ensuring the horizontal comparability of multi-condition results from the source.

[0208] Step B4: Parallel Subtask Issuance and Execution Control. After the common parent task passes verification, the central coordinator agent creates independent parallel simulation subtasks for each working condition, and issues subtask instructions, baseline model call permissions, and corresponding personalized parameter sets in batches through a unified standardized interface according to preset priorities and resource allocation rules;

[0209] The central coordinator intelligent agent monitors the execution progress, heartbeat status and abnormal situations of all subtasks in real time, completes the closed-loop handling of single-condition anomalies according to preset rules, avoids the spread of anomalies, and summarizes the full-condition simulation results after all parallel subtasks have been executed and verified.

[0210] Step B5: Multi-condition comparative analysis and cross-condition collaborative optimization. The central coordinator agent issues multi-condition comparative analysis tasks to the result analysis agent to complete the consistency verification of the results across all conditions, horizontal comparative analysis, and selection of feasible solutions;

[0211] The central coordinator's built-in multi-condition parallel scheduling module, based on multi-condition analysis results, constrains compliance with all-condition performance indicators, and aims for optimal comprehensive performance. It constructs a multi-objective optimization agent model, completes global optimization through a multi-objective optimization algorithm, obtains the Pareto optimal solution set, combines user-preset optimization priorities to select the optimal solution, and automatically drives each agent to complete the verification simulation of the optimal solution to confirm the effectiveness of the solution.

[0212] Step B6: Report Output and Knowledge Base Update. The central coordinator agent sends a multi-condition report generation task to the report generating agent, integrates the full-process data, multi-condition comparison results, optimization process and verification data, generates a standardized multi-condition simulation analysis report and outputs it to the user, and marks the master state machine as completed;

[0213] The standardized archiving of all data from this multi-condition task was completed, and the knowledge base was automatically updated according to preset rules. This concludes the closed-loop process of multi-condition simulation and collaborative optimization.

[0214] This invention constructs a hierarchical multi-agent collaborative architecture with a central coordinator agent at its core, complemented by a system-wide standardized decoupling interface system, and a dynamically updatable knowledge base. Combined with a large language model, it achieves accurate intent parsing and task scheduling and execution throughout the simulation process. This overcomes the inherent limitations of the simple serial architecture of peer-to-peer agents in existing technologies, and solves the defects of existing solutions such as high coupling between agents, inconsistent interfaces, poor scalability, and inability to flexibly adapt to complex industrial simulation scenarios such as multi-condition parallelism and multi-physics coupling. It achieves complete decoupling and flexible expansion of each agent.

[0215] Meanwhile, by establishing a real-time monitoring mechanism for the entire process execution status and a cross-stage anomaly root cause tracing and linkage repair system, this invention constructs a complete closed-loop autonomous process from perception, planning, execution, and repair. It solves the problems of traditional simulation processes and existing intelligent agent solutions, which can only achieve forward process automation, cannot handle cross-stage chain anomalies, cannot get rid of errors and stop, and cannot be repaired by human intervention. This reduces the dependence of the entire finite element simulation process on the personal experience of engineers, improves the efficiency of simulation analysis, the consistency and reproducibility of simulation results, and effectively shortens the simulation iteration cycle of high-end equipment product development.

[0216] The above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention in any way. Although the present invention has been disclosed above with reference to preferred embodiments, it is not intended to limit the present invention. Any person skilled in the art can make some modifications or alterations to the above-disclosed technical content to create equivalent embodiments without departing from the scope of the present invention. Any indirect modifications, equivalent changes and alterations made to the above embodiments based on the technical essence of the present invention without departing from the scope of the present invention shall still fall within the scope of the present invention.

Claims

1. An end-to-end finite element analysis system based on multi-agent collaboration, characterized in that, This includes a knowledge base and a multi-agent framework; The knowledge base is used to store the underlying data related to the entire process of finite element simulation analysis. The underlying data includes at least error diagnosis modes, simulation experience rules, and simulation cases. The multi-agent framework includes a central coordinator agent and multiple agents. The central coordinator agent is communicatively connected to the knowledge base and the multiple agents, respectively, and is used to receive user input, parse the user input based on the knowledge base and generate structured tasks, and uniformly coordinate and manage the multiple agents to execute the simulation links corresponding to the structured tasks. The plurality of intelligent agents are respectively connected to the central coordinator intelligent agent for executing their respective simulation tasks under the unified coordination and control of the central coordinator intelligent agent, and for feeding back the execution status and simulation results to the central coordinator intelligent agent. All agents within the multi-agent framework use a unified standardized interface for data interaction. During the data interaction process, only the central coordinator agent has the authority to actively issue tasks. There is no direct call between the other agents, and all cross-agent data interactions are forwarded through the central coordinator. The central coordinator intelligent agent has a built-in multi-condition parallel scheduling module. When the user input includes multiple parallel simulation conditions, the multi-condition parallel scheduling module is used to identify the common and individual parameters of the parallel conditions, merge the common execution links into a common parent task, split the individual execution links of each condition into parallel sub-tasks, construct a tree-shaped task structure of common parent task and parallel sub-tasks, allocate execution priority and computing resources to each parallel sub-task, and control the execution sequence of parallel tasks. The central coordinator agent has built-in multi-condition benchmark consistency mandatory control rules, and after all parallel subtasks are executed, it summarizes the simulation results of all conditions and performs cross-condition collaborative optimization based on the multi-condition results. The multi-condition benchmark consistency mandatory control rule is as follows: after the common parent task is completed, a benchmark model with a unique identifier is generated. The benchmark model includes a benchmark geometric model and a benchmark mesh model. All geometric features, mesh parameters, and quality standards of the benchmark model are locked, and any modification by parallel subtasks is prohibited. When all parallel subtasks are issued, only individual parameters are attached. These individual parameters are three categories: load parameters, material parameters, and boundary condition parameters, which differ between different working conditions. Parallel subtasks must directly call the locked reference model and are prohibited from modifying the reference geometry and reference mesh. The knowledge base pre-stores solution convergence criterion rule templates and result extraction rule templates for different analysis types, element types, mesh quality levels, and solver configuration scenarios. All parallel subtasks adhere to the same grid quality standards, solution convergence standards, and result extraction rules.

2. The end-to-end finite element analysis system based on multi-agent cooperation according to claim 1, characterized in that, The central coordinator agent is equipped with a large language model, which has been fine-tuned using labeled data from the finite element simulation domain. The large language model is used to parse the natural language input by the user based on the knowledge base, extract the simulation intent and key parameters, and generate standardized structured tasks.

3. The end-to-end finite element analysis system based on multi-agent cooperation according to claim 2, characterized in that, The central coordinator agent is specifically used for: The structured task is divided into predetermined modules, including at least a mesh control module, a simulation solution control module, and a result analysis control module; The mesh control module is sent to the mesh generation agent, the simulation solution control module is sent to the simulation solution agent, and the result analysis control module is sent to the result analysis agent, so as to serve as standardized inputs for each agent to perform the corresponding simulation task.

4. The end-to-end finite element analysis system based on multi-agent cooperation according to claim 1, characterized in that, The specific process by which the multi-condition parallel scheduling module performs cross-condition collaborative optimization is as follows: The simulation results of all parallel subtasks are summarized. The performance indicators of all working conditions meet the design allowable value as a constraint. The performance indicators of all working conditions are used as optimization objectives. Structural geometric parameters and material parameters are used as optimization variables. The value range of each optimization variable is used to construct a design space. The space filling sampling method is used to automatically generate supplementary sampling points in the design space. Each agent is driven to complete the supplementary simulation calculation. The supplementary simulation results are merged with the original parallel working condition simulation results to form a full training sample set covering the design space. A multi-objective optimization agent model is constructed based on the full training sample set. A global optimization is performed through a multi-objective optimization algorithm to obtain a Pareto optimal solution set. After selecting the optimal solution from the Pareto optimal solution set based on the optimization priority input by the user, the model automatically drives each agent to perform verification simulation and finally outputs the optimal structural scheme and verification results.

5. The end-to-end finite element analysis system based on multi-agent cooperation according to claim 1, characterized in that, The central coordinator intelligent agent has a built-in multi-physics coupling and collaborative management module. When the user inputs multi-physics coupling analysis, the multi-physics coupling and collaborative management module is used to decompose the physical field composition, data transmission direction and coupling iteration rules of the coupling field, plan the execution sequence of each physical field analysis, create an independent simulation solution subtask for each physical field analysis, and manage the execution start and stop and data transmission of each subtask.

6. The end-to-end finite element analysis system based on multi-agent cooperation according to claim 5, characterized in that, The multi-physics coupling collaborative management module monitors the iterative convergence status of each physical field solution subtask in real time for bidirectional coupling analysis. When the calculation results of all physical fields reach the convergence threshold or the maximum number of iterations, the coupling iteration process is terminated. The results data between different physical field subtasks are all converted and forwarded in a standardized format by the central coordinator agent.

7. The end-to-end finite element analysis system based on multi-agent cooperation according to claim 1, characterized in that, The central coordinator intelligent agent has a built-in full-process status monitoring and closed-loop management module, which is used for: Real-time monitoring of the heartbeat packets and execution progress feedback of each agent; creation and updating of a full-process state machine containing the sub-states of each execution stage for the simulation task. Based on the judgment results of the full-process state machine, control commands, including normal process progress, pause, backtracking, restart or termination, are issued to each intelligent agent.

8. The end-to-end finite element analysis system based on multi-agent cooperation according to claim 7, characterized in that, The full-process status monitoring and closed-loop management module is also used for: Pre-defined compliance verification rules are set for the execution results of each simulation stage, and the verification rules are derived from the knowledge base; The task issuance for the next stage will only be triggered after the execution result of the current stage passes the compliance check.

Images