Aero-engine design method based on sysml activity diagram native driving and ai autonomous decision

Abstract

The application provides an aero-engine design method based on SysML activity diagram native driving and AI autonomous decision, and belongs to the technical field of aero-engines, and comprises the following steps: constructing a SysML model integrating engine architecture and behavior, wherein the SysML model is constructed based on a SysML activity diagram; loading the SysML model by a diagram explanation engine based on asynchronous event driving, and driving a simulation calculation process by managing the life cycle of a token; when the simulation calculation is performed, performing AI autonomous decision and pruning strategy based on Bayesian inference, including dynamic pruning based on a sensitivity matrix and autonomous optimization based on Gaussian process regression; and associating the simulation calculation result with the attributes of the SysML model by the system automation to complete integration. The scheme reduces the communication and maintenance cost of a complex system, improves the process observability and debugging efficiency, and realizes intelligent scheduling and data alignment based on an architecture context.

Description

Technical Field

[0001] This application relates to the field of aero-engine technology, and in particular to an aero-engine design method based on SysML activity graph native driving and AI autonomous decision-making. Background Technology

[0002] Aero-engines are a deep integration of multiple disciplines, including materials, processes, aerodynamics, thermodynamics, and control, and must operate stably under extremely harsh conditions of high temperature, high pressure, and high speed. Their development involves numerous procedures supporting the design of multiple components, requiring multidisciplinary collaboration and demanding extremely high levels of systematicity, logic, and traceability in the program execution flow. SysML (Systems Modeling Language) is used to define system architecture and design goals; however, when entering the design simulation phase, engineers typically need to leave the SysML environment and use scripts (Python / Bat) or third-party integrated software (such as ModelCenter) to redraw the simulation flow and call tools for calculations. Currently, there is an urgent need for efficient and automated design methods that can couple SysML with design simulation tools.

[0003] In recent years, MBSE (Model-Based Systems Engineering) technology has evolved from static "drawing and modeling" to dynamic "executable modeling":

[0004] Phase 1 (Static Modeling): Only SysML is used to draw BDD (Block Definition Diagram) / IBD (Internal Block Diagram) to represent the system composition, and simulation verification is carried out independently outside the model.

[0005] The second stage (integration-driven): Commercial integration platforms such as ModelCenter, Isight, and CameoSimulationToolkit emerged. These tools can export SysML parameters to external simulation software (such as Ansys and Matlab), initially realizing the automation of the workflow.

[0006] Current Trends and Bottlenecks: The industry is attempting to introduce AI (Artificial Intelligence) to accelerate design. However, current AI applications are mostly limited to "single-point acceleration" (such as replacing a CFD calculation with a proxy model), lacking system-level intelligent scheduling. That is, the SysML architecture model, simulation process, and AI decision-making are still separate, and a closed-loop system that can autonomously adjust strategies based on operational conditions has not yet been formed. Summary of the Invention

[0007] In view of this, the embodiments of this application provide an aero-engine design method based on SysML activity graph native driving and AI autonomous decision-making, which at least partially solves the problems of the existing technology where SysML architecture model, simulation process and AI decision-making are separated, and there is a lack of system-level intelligent scheduling and closed-loop autonomous adjustment strategies.

[0008] This application provides an aero-engine design method based on SysML activity graph native driving and AI autonomous decision-making, including: A SysML model integrating engine architecture and behavior is constructed, and the SysML model is built based on SysML activity graphs; The SysML model is loaded based on an asynchronous event-driven graph interpretation engine, and the simulation calculation process is driven by the lifecycle of the management token. During simulation calculations, AI autonomous decision-making and pruning strategies based on Bayesian inference are implemented, including dynamic pruning based on the sensitivity matrix and autonomous optimization based on Gaussian process regression. The system automatically associates the simulation results with the properties of the SysML model to complete the integration.

[0009] According to a specific implementation of an embodiment of this application, the construction of a SysML model integrating engine architecture and behavior includes: Define different levels of structural units for engines, components, and parts; The design flow is drawn using SysML activity diagrams. Each action in the design flow is defined by directly referencing the structural units in the architecture, so as to achieve strong coupling between structure and behavior.

[0010] According to a specific implementation of an embodiment of this application, the simulation calculation process driven by the lifecycle of the management token includes: At the start of the simulation computation process, the graph interpretation engine generates a control token at the initial node of the SysML activity graph, which carries a context reference to the current SysML model instance; The control token moves along the control flow or object flow connection in the SysML activity graph. When the control token encounters a fork node, the driving engine uses object cloning technology to create multiple copy tokens and pushes the copy tokens to all downstream branches. When a control token or a copy token arrives at an input pin of an action node, a listener check is triggered to check whether all input pins associated with that action node have a token residing there. If so, the listener consumes all tokens associated with the action node for data input and sets the action node's state to be executing; The graph interpretation engine extracts the data carried in the token and encapsulates it into instructions, which are then sent to the simulation execution layer for simulation calculations. After the simulation calculation is completed, the semantic backfilling engine writes the simulation calculation results into the properties of the SysML model instance, and the sandbox sends a signal to the graph interpretation engine that the calculation is complete. After receiving the signal, the graphical explanation engine generates a new data token on the output pin of the action node. This new data token carries the simulation calculation results that have been written into the properties of the SysML model instance. The graph interpretation engine pushes the new data token downstream, triggering the execution of subsequent action nodes.

[0011] According to a specific implementation of an embodiment of this application, the dynamic pruning based on the sensitivity matrix includes: Construct an AI decision agent and maintain a dynamically updated sensitivity matrix. The elements in the sensitivity matrix are used to represent the approximate values ​​of the partial derivatives of the input parameters of the simulation calculation with respect to the key performance indicators of the output. When a design iteration occurs, the parameter difference vector between the current SysML model instance and the previous version of the SysML model instance is calculated. Based on the sensitivity matrix and parameter difference vector, the expected changes in key performance indicators are calculated. If the expected change in key performance indicators is less than the first preset threshold, the input parameters are determined to be invalid changes. The AI ​​decision agent issues an instruction to skip execution, directly reuses historical results, and skips time-consuming simulation calculations. If the expected change in key performance indicators is greater than or equal to the first preset threshold, the input parameters are determined to be valid changes, and the AI ​​decision agent issues an instruction to execute the simulation, driving the simulation tool to run.

[0012] According to a specific implementation of an embodiment of this application, the expression for the expected change in the key performance indicator is as follows: , Where, ΔY j S represents the expected change in the j-th key performance indicator; ij S is an element in the sensitivity matrix. ij This represents the i-th input parameter x. i For every unit change, the target value Y of the j-th key performance indicator... j The resulting pulling force; Δx i These are the components of the parametric difference vector Δx; It is the transpose of the row vector corresponding to the j-th key performance indicator in the sensitivity matrix.

[0013] According to a specific implementation of an embodiment of this application, the method further includes: After the semantic backfilling engine writes the simulation calculation results into the properties of the SysML model instance, the SysML constraint checker triggers autonomous optimization based on Gaussian process regression when it finds that the key performance indicators exceed the constraints.

[0014] According to a specific implementation of an embodiment of this application, the autonomous optimization based on Gaussian process regression includes: The AI ​​decision agent reads sample data from the historical version library of SysML models and trains a Gaussian process regression model based on the sample data to fit the nonlinear relationship between input parameters and output. Based on the Gaussian process regression model, the predicted mean and predicted standard deviation of multiple input parameters corresponding to the key performance indicators that exceed the constraints are given; Based on the predicted mean and predicted standard deviation, calculate the expected improvement function corresponding to each input parameter; AI decision-making agents seek the input parameters corresponding to the maximum value in the expected improvement function; The AI ​​decision agent directly calls the SysML API to modify the found input parameters and automatically restarts the simulation calculation process until the constraints are met.

[0015] According to a specific implementation of an embodiment of this application, the expression of the desired promotion function is: , Where EI(x) is the expected improvement function; σ(x) is the prediction standard deviation; z represents the standardized improvement space, which measures the extent to which the predicted mean μ(x) is better than the current known best value, and has been adjusted for uncertainty. and These are the cumulative distribution function and probability density function of the standard normal distribution, respectively.

[0016] According to a specific implementation of an embodiment of this application, the system automatically associates the simulation calculation results with the attributes of the SysML model, including: The process-driven engine captures simulation calculation results, builds a Prompt, and feeds it to the locally deployed lightweight LLM. The LLM automatically generates standardized intermediate state JSON format files. Iterate through all empty slots in the SysML model instance. For each empty slot, the system performs multi-dimensional similarity calculations between its metadata and each candidate parameter in the JSON file to obtain the total matching score for each empty slot. If the total matching score exceeds the second preset threshold, a mapping will be automatically established and the values ​​in the JSON file will be filled back into the empty slots corresponding to the total matching score.

[0017] According to a specific implementation of an embodiment of this application, the multi-dimensional similarity calculation includes name semantic similarity calculation, dimensional physical consistency calculation, and structural topological matching calculation.

[0018] Beneficial effects: The aero-engine design method based on SysML activity graph native driving and AI autonomous decision-making in this application embodiment has the following advantages compared with the prior art: 1. It achieves absolute unity between "design intent" and "execution logic": In traditional techniques, architects draw diagrams in SysML, while simulation engineers write a separate set of logic in Python, often leading to conflicts. However, the SysML activity diagram in this application directly serves as the execution logic. Architects can modify the process in SysML (such as changing the calculation order), and the underlying execution engine takes effect immediately, eliminating the gap between design and simulation and significantly reducing the communication and maintenance costs of complex systems.

[0019] 2. It gives standard modeling languages ​​"dynamic vitality": In traditional techniques, SysML diagrams are merely static documents, dead once drawn. However, the method in this application, through a token-driven mechanism, transforms the SysML activity diagram into a visual, dynamic console. Designers can intuitively see tokens flowing across the diagram, branches branching in parallel, and loops iterating, greatly improving the observability and debugging efficiency of the process.

[0020] 3. Implemented intelligent scheduling and data alignment based on architectural context: Because the process directly manipulates SysML instance objects (rather than cold files), the AI ​​agent can easily obtain the complete architectural context (such as component hierarchy, material properties, and upstream design constraints). This makes AI pruning and optimization decisions more accurate, automatically integrates with new tools, and avoids blind calculations detached from the physical context. Attached Figure Description

[0021] To more clearly illustrate the technical solutions of the embodiments of this application, the drawings used in the embodiments will be briefly introduced below. Obviously, the 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.

[0022] Figure 1 This is a flowchart of an aero-engine design method based on SysML activity graph native driving and AI autonomous decision-making, according to an embodiment of the present invention. Detailed Implementation

[0023] The embodiments of this application will now be described in detail with reference to the accompanying drawings.

[0024] The following specific examples illustrate the implementation of this application. Those skilled in the art can easily understand other advantages and effects of this application from the content disclosed in this specification. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of them. This application can also be implemented or applied through other different specific embodiments, and the details in this specification can also be modified or changed based on different viewpoints and applications without departing from the spirit of this application. It should be noted that, in the absence of conflict, the following embodiments and features in the embodiments can be combined with each other. Based on the embodiments in this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0025] It should be noted that various aspects of embodiments within the scope of the appended claims are described below. It will be apparent that the aspects described herein can be embodied in a wide variety of forms, and any particular structure and / or function described herein is merely illustrative. Based on this application, those skilled in the art will understand that one aspect described herein can be implemented independently of any other aspect, and two or more of these aspects can be combined in various ways. For example, any number of aspects set forth herein can be used to implement the device and / or practice the method. Additionally, this device and / or method can be implemented using structures and / or functionalities other than one or more of the aspects set forth herein.

[0026] It should also be noted that the illustrations provided in the following embodiments are only schematic representations of the basic concept of this application. The illustrations only show the components related to this application and are not drawn according to the number, shape and size of the components in actual implementation. In actual implementation, the form, quantity and proportion of each component can be arbitrarily changed, and the layout of the components may also be more complex.

[0027] Furthermore, specific details are provided in the following description to facilitate a thorough understanding of the examples. However, those skilled in the art will understand that the described aspects can be practiced without these specific details.

[0028] This application provides an aero-engine design method based on native SysML activity graph-driven and AI-autonomous decision-making. It proposes a "Diagram as Code" driving mode, directly parsing the XMI metadata (XML Metadata Interchange) of the SysML activity graph and converting it into an executable directed graph (DAG) in memory. This ensures that the design logic (process) and system architecture (model) are defined within the same semantic space, achieving the uniformity of "architectural change equals process change," eliminating the need to maintain two separate systems. Furthermore, it proposes AI-agent-based autonomous process pruning and inversion decision-making: introducing AI decision nodes during SysML activity graph execution; intelligent pruning: autonomously deciding to skip certain SysML action nodes based on parameter sensitivity prediction; and automatic optimization: when the backfill result is unsatisfactory, AI automatically takes over the control flow, triggering a parameter inversion loop within the SysML semantic framework. Furthermore, a semantically aware, rule-based automatic backfilling technique is proposed: utilizing LLM (Large Language Model) and vector space models to achieve automated mapping of unstructured outputs from heterogeneous simulation tools to SysML architecture instance slots. The following section, in conjunction with the appendix... Figure 1 This method will be explained in detail.

[0029] In one embodiment, the aero-engine design method based on SysML activity graph native driving and AI autonomous decision-making includes the following steps: Step 1: Construct a SysML model that integrates engine architecture and behavior. The SysML model is built based on SysML activity graphs. Step 2: Load the SysML model using an asynchronous event-driven graph interpretation engine, and drive the simulation calculation process by managing the lifecycle of the token; Step 3: During the simulation calculation, implement AI autonomous decision-making and pruning strategies based on Bayesian inference, including dynamic pruning based on the sensitivity matrix and autonomous optimization based on Gaussian process regression. Step 4: The system automatically associates the simulation calculation results with the properties of the SysML model to complete the integration.

[0030] In this embodiment, the SysML model integrating engine architecture and behavior constructed in step 1 lays a unified semantic foundation for the entire design process, enabling a clear and consistent definition of the engine's structural components and operational behavior within the same framework. The asynchronous event-driven graph interpretation engine introduced in step 2, through effective management of token lifecycles, achieves precise and efficient driving of the simulation calculation process defined by the SysML model, ensuring that the design logic is executed systematically according to the predetermined activity graph sequence and rules. In step 3, the AI ​​autonomous decision-making and pruning strategies based on Bayesian inference, particularly the dynamic pruning based on the sensitivity matrix, can intelligently identify and skip SysML action nodes with minimal impact on the final result based on the sensitivity of parameters to the design objective, thereby significantly improving simulation efficiency and avoiding unnecessary resource consumption. Furthermore, the autonomous optimization based on Gaussian process regression can drive parameter inversion loops and automatically adjust relevant design parameters to seek a better design solution when the backfilling results do not meet the expected goals during simulation. Finally, step 4 automates the association and integration of simulation results with SysML model attributes, enabling the accurate and timely feedback of large amounts of data generated during the design process into the model, forming a closed-loop design iteration process. This method effectively integrates SysML's architectural modeling capabilities with AI's autonomous decision-making and optimization capabilities, achieving the integration and automation of aero-engine design from architecture definition, process driving, intelligent decision-making to result integration, providing strong technical support for improving the efficiency, quality, and innovation of aero-engine design.

[0031] Furthermore, the construction of the SysML model integrating engine architecture and behavior includes: Engine architecture definition model: Defines the different levels of structural units (blocks) for engines, components, and parts. Process definition (within SysML): The design process is drawn using SysML activity diagrams. Each action in the design process is defined by directly referencing the structural unit (Block) in the architecture to achieve strong coupling between structure and behavior.

[0032] In practice, when defining different levels of Blocks, attributes such as structure and performance parameters must be included. For example, a process definition might include: Use Action Node to represent "Execute CFD" and "Execute Structure Analysis"; Use Object Flow (which connects to the output pins of action nodes) to represent the transfer of architecture instance data (such as a Compressor Instance) in the process; Use Decision Node to represent logical decision points.

[0033] In this step, every action in the process directly references the Block definition in the architecture, achieving strong coupling between structure and behavior.

[0034] In one embodiment, the simulation computation process driven by the lifecycle of the management token includes: Phase 1, Token Generation: When the simulation computation process begins (when the user clicks "Run"), the graph interpretation engine generates a control token in the initial node of the SysML activity graph. This control token carries a context reference of the current SysML model instance. Phase 2, Topological Routing: The control token moves along the control flow or object flow of the SysML activity graph. When the control token encounters a fork node, fork logic is performed. The driving engine instantly replicates multiple replica tokens using object cloning technology (Deep Copy) and pushes the replica tokens to all downstream branches. Phase 3, Ignition and Execution: When the control token or replica token arrives at the input pin of an action node (such as "Execute CFD"), a listener check is triggered. The listener checks whether all input pins associated with the action node have tokens residing there (ignition determination). If so, the listener consumes all tokens associated with the action node for data input and sets the action node's state to Running. Suspension and Delegation: The SysML graph interpretation engine itself does not perform heavy scientific calculations. The graph interpretation engine extracts the data (Payload, such as geometric parameters) carried in the token and encapsulates it into instructions to send to the simulation execution layer for simulation calculations. At this time, the action node is displayed as "highlighted / busy" on the SysML graph, and the token temporarily disappears (enters black-box calculation). Phase 4, Result Encapsulation and Implementation: After the underlying simulation program (such as Fortran) completes the simulation calculation, the semantic backfilling engine writes the simulation calculation results into the properties of the SysML model instance, and the sandbox sends a signal to the graph interpretation engine that the calculation is complete. After receiving the signal, the graphical explanation engine generates a new data token on the output pin of the action node. This new data token carries the simulation calculation result (such as Efficiency=0.91) that has been written into the properties of the SysML model instance. The graph interpretation engine pushes the new data token downstream, triggering the execution of subsequent action nodes.

[0035] This embodiment proposes an asynchronous event-driven graph interpreter engine, replacing the traditional code generation model. This engine directly loads the in-memory model of the SysML activity graph and drives the simulation process by managing the lifecycle of "tokens," specifically including: Parsing Engine: When the user clicks "Run", the system does not generate a Python script, but instead launches the Graph Interpreter. Token Flow Mechanism: The graph interpreter generates a control token at the Initial Node of the SysML activity graph. Parallel Driving: When the token flows to a fork node, the system automatically splits the token, driving the downstream activities (e.g., "Aerodynamic Analysis" and "Structural Analysis") in parallel. This leverages SysML's native concurrency semantics without requiring complex multithreaded code. Context Passing: The token carries a pointer to the current SysML architecture instance, meaning that the tool at any given step in the process can directly read the latest attribute values ​​of that instance without needing to pass parameters via files. An event bus mechanism is used.

[0036] Therefore, this embodiment achieves visualized orchestration and execution of the simulation process. Users can directly define complex multidisciplinary simulation logic through SysML activity graphs without needing to deeply write underlying code, reducing the requirements for users' programming skills and improving the intuitiveness and convenience of design process construction. Secondly, by leveraging the token forking and parallel push mechanism, it naturally supports the native concurrent semantics of SysML activity graphs, efficiently driving the parallel execution of multi-branch tasks, significantly shortening the overall simulation computation time and improving design efficiency. Thirdly, the token carries a context reference to the SysML model instance, ensuring that each action node in the process can directly obtain the latest attribute values ​​of the current model instance, avoiding problems such as data inconsistency, transmission delays, and version management chaos that may occur with traditional file parameter transmission, ensuring the accuracy and real-time nature of data transmission. Fourthly, by adopting an asynchronous event-driven graph interpretation engine, simulation computation tasks are delegated to a dedicated simulation execution layer, decoupling the graph interpretation engine from the underlying computing resources. This makes the engine itself more lightweight, capable of efficiently responding to and processing various events during the simulation process, and also facilitates independent optimization and expansion of the simulation execution layer, improving the system's flexibility and maintainability.

[0037] In one embodiment, to address the problem of blind calculation in traditional processes, this embodiment introduces an AI decision agent to dynamically calculate the "execution value" during process execution. Specifically, the dynamic pruning based on the sensitivity matrix includes: Data Structure: Construct an AI decision agent and maintain a dynamically updated sensitivity matrix. The elements in the sensitivity matrix are used to represent the approximate values ​​(weights) of the partial derivatives of the input parameters of the simulation calculation with respect to the key performance indicators of the output. In each iteration, the sensitivity matrix is ​​continuously updated based on historical data to ensure that the reliability of the sensitivity is getting higher and higher. Decision logic: 1. Change vector calculation: When a design iteration occurs, calculate the parameter difference vector between the current SysML model instance and the previous version of the SysML model instance; 2. Impact Domain Prediction: Based on the sensitivity matrix and parameter difference vector, calculate the expected changes in key performance indicators (such as efficiency); 3. Binary decision: If the expected change in key performance indicators is less than the first preset threshold (engineering ignore threshold), the input parameters are determined to be invalid changes. The AI ​​decision agent issues an instruction to skip execution, directly reuses historical results, and skips time-consuming simulation calculations. If the expected change in key performance indicators is greater than or equal to the first preset threshold, the input parameters are determined to be valid changes, and the AI ​​decision agent issues an instruction to execute the simulation, driving the simulation tool to run.

[0038] Furthermore, the expression for the expected change in the key performance indicator is as follows: , Where, ΔY j Let S be the expected change in the j-th key performance indicator, and let S be a scalar. ij The elements in the sensitivity matrix are essentially partial derivatives. The discrete approximation value, S ij This represents the i-th input parameter x. i (e.g., blade installation angle, aspect ratio, etc.) For each unit change, the target value Y of the j-th key performance indicator... j The resulting pulling force; Δx i The components of the parameter difference vector Δx represent the i-th input parameter x in the current SysML model instance. i Changes compared to the previous version; It is the transpose of the row vector corresponding to the j-th key performance indicator in the sensitivity matrix.

[0039] In this embodiment, a dynamic pruning strategy based on the sensitivity matrix significantly reduces unnecessary computational resource consumption while ensuring design accuracy. When parameter changes have a negligible impact on key performance indicators, within the engineering-allowed threshold, the system no longer initiates computationally expensive CFD simulations. Instead, it directly calls and reuses historical simulation results, thereby drastically shortening the single iteration cycle and improving the overall efficiency of the design process. This mechanism effectively avoids the computational waste and time delays caused by indiscriminate simulation calculations for all parameter changes in traditional methods, allowing designers to focus more on adjusting parameters that truly have a significant impact on performance optimization.

[0040] In one embodiment, the method further includes: After the semantic backfilling engine writes the simulation calculation results into the properties of the SysML model instance, the SysML constraint checker triggers autonomous optimization based on Gaussian process regression when it finds that the key performance indicators exceed the constraints.

[0041] Furthermore, the autonomous optimization based on Gaussian process regression includes: Agent modeling: The AI ​​decision agent reads sample data from the historical version library of SysML models and trains a Gaussian process regression model based on the sample data to fit the nonlinear relationship between input parameters and output. Based on the Gaussian process regression model, the predicted mean and predicted standard deviation of multiple input parameters corresponding to the key performance indicators that exceed the constraints are given; Optimization of the acquisition function: Based on the predicted mean and predicted standard deviation, calculate the expected improvement function (EI) for each input parameter. AI decision-making agents seek the input parameters corresponding to the maximum value in the expected improvement function; The AI ​​decision agent directly calls the SysML API to modify the found input parameters and automatically restarts the simulation calculation process until the constraints are met.

[0042] Furthermore, the expression for the expected lifting function is: , Where EI(x) is the expected improvement function; σ(x) is the prediction standard deviation, representing the magnitude of uncertainty, which, as the total gain, determines how ambitious the exploration is; z represents the standardized improvement space, used to measure the degree to which the predicted mean μ(x) is better than the current known best value, and has been discounted for uncertainty. and These are the cumulative distribution function and probability density function of the standard normal distribution, respectively.

[0043] In practice, the AI ​​decision-making agent uses a reverse tracing algorithm to determine which upstream node in the process needs to be revisited for a new iteration: 1. Construct a candidate pool (Candidate Generation): Starting from failure indicators, the AI ​​decision agent traverses all upstream nodes in reverse to find the set of all input parameters that can affect the result. For example, parameters that affect surge margin include: x1: stator blade angle (defined in the "CFD preprocessing" step), x2: blade sweep angle (defined in the "geometric modeling" step), and x3: compressor stage number (defined in the "architecture definition" step).

[0044] 2. Calculate the "corrected cost-effectiveness" score: The AI ​​decision-making agent calculates a score for each process step in the input parameter set, representing the candidate parameter. Molecular (Sensitivity): Does modifying this parameter significantly improve the results? (Changing the "Series" has the greatest impact, followed by changing the "Angle", while changing the "Chamfer" has no effect).

[0045] Denominator (Recalculation Cost): If we roll back to this step, how long will it take to rerun the code? (Changing the "series" requires redrawing the graph, redrawing the mesh, and recalculating the CFD, which is extremely costly; changing the "stationary leaf angle" only requires recalculating the CFD, which is moderately costly).

[0046] 3. Select the optimal backtracking node: The AI ​​decision agent divides the "sensitivity" of each candidate parameter in the step by the "recalculation cost" to obtain the "correction cost-effectiveness" score. The node with the highest score is the optimal backtracking point.

[0047] By setting up an autonomous optimization strategy based on Gaussian process regression, the proxy modeling and optimization process can be quickly initiated when key performance indicators exceed constraints. The Gaussian process regression model accurately fits the nonlinear relationship of the input parameters, and the expected improvement function is used to quantitatively evaluate the parameter improvement space. This mechanism not only avoids the resource waste caused by blind trial and error in traditional optimization methods, but also effectively balances the development of known high-potential areas and the exploration of unknown areas by ensuring the accuracy of the optimization direction through the synergistic effect of the predicted mean and standard deviation. Furthermore, the reverse tracing algorithm used by the AI ​​decision-making proxy, by constructing a candidate pool and calculating a "correction cost-effectiveness" score, can accurately locate the optimal backtracking point with high sensitivity and low recalculation cost from numerous upstream nodes affecting failure indicators. This greatly shortens the iteration cycle and significantly improves the efficiency and accuracy of autonomous decision-making in the aero-engine design process, enabling the entire design process to achieve dynamic and efficient self-correction and performance improvement under complex constraints.

[0048] In one embodiment, AI-based semantic backfilling and architectural evolution are performed, including the system automatically associating simulation calculation results with the attributes of the SysML model. This integration is completed without writing a single line of regular expressions or configuring any JSON rule files. Specifically, this includes: The process-driven engine extracts simulation results, constructs a Prompt, and feeds it to a locally deployed lightweight LLM (such as Deepseek). The LLM automatically generates a standardized intermediate JSON file. A Prompt example: "Analyze the following engineering simulation results, extract all physical parameters, and output in JSON format. It must include variable names, values, and estimated units." In the context of a large language model (LLM), a Prompt refers to the user's input instructions or query text, guiding the model to generate responses according to specific format, style, or content requirements. Iterate through all empty slots in the SysML model instance. For each empty slot, the system performs multi-dimensional similarity calculations between its metadata and each candidate parameter in the JSON format file to obtain the total matching score for each empty slot. If the total matching score exceeds the second preset threshold (e.g., 0.9), a mapping will be automatically established and the value from the JSON file will be filled back into the empty slot corresponding to the total matching score.

[0049] Furthermore, the multi-dimensional similarity calculation includes name semantic similarity calculation, dimensional physical consistency calculation, and structural topological matching calculation.

[0050] For example, multi-dimensional similarity calculation includes: Dimension 1: Name semantic similarity, using an embedding model (such as BERT) to calculate vector cosine similarity; Dimension 2: Physical consistency of units. If the units are incompatible, the system will be eliminated and the score will be 0. Dimension 3: Structural topology matching, data structure consistency, bonus points.

[0051] Furthermore, once the user clicks "Confirm," the system stores the confirmed relationship in the "Synonym Knowledge Graph." The next time the user encounters this tool, or another new tool with the same variable name, the system will directly determine a 100% match based on the synonym knowledge graph.

[0052] The following is an illustration using a specific example (scenario: integrating a completely new self-developed pneumatic code): The pneumatics team developed a new program, SuperAero.exe, which had never been integrated into the SysML platform before. Its output file format was arbitrary, with no documentation provided.

[0053] Action: The user drags the new program into SysML and clicks "Automatic Scan Interface"; AI Analysis: The engine reads the program's example output file. LLM identifies a line: MassFlow(Inlet): 50.5 kg / s. LLM extracts this as {"name": "MassFlow(Inlet)", "val": 50.5, "unit": "kg / s"}, where name is the variable name, val is the numerical value, unit is the unit, and MassFlow(Inlet) is the inlet mass flow rate. Automatic matching: In the SysML model, there is an attribute called inlet_mass_flow, measured in kg / s. The algorithm calculates that "MassFlow(Inlet)" and "inlet_mass_flow" have a very close semantic distance, resulting in a perfect match. Result: The system automatically connected the two. The user completed the integration of the new tool without writing a single line of regular expressions or configuring any JSON rule files.

[0054] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the technical scope disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

Claims

1. An aero-engine design method based on SysML activity graph native driving and AI autonomous decision-making, characterized in that, include: A SysML model integrating engine architecture and behavior is constructed, and the SysML model is built based on SysML activity graphs; The SysML model is loaded based on an asynchronous event-driven graph interpretation engine, and the simulation calculation process is driven by the lifecycle of the management token. During simulation calculations, AI autonomous decision-making and pruning strategies based on Bayesian inference are implemented, including dynamic pruning based on the sensitivity matrix and autonomous optimization based on Gaussian process regression. The system automatically associates the simulation results with the properties of the SysML model to complete the integration.

2. The aero-engine design method based on SysML activity graph native driving and AI autonomous decision-making as described in claim 1, characterized in that, The construction of the SysML model integrating engine architecture and behavior includes: Define different levels of structural units for engines, components, and parts; The design flow is drawn using SysML activity diagrams. Each action in the design flow is defined by directly referencing the structural units in the architecture, so as to achieve strong coupling between structure and behavior.

3. The aero-engine design method based on SysML activity graph native driving and AI autonomous decision-making as described in claim 1, characterized in that, The simulation calculation process driven by the lifecycle of the management token includes: At the start of the simulation computation process, the graph interpretation engine generates a control token at the initial node of the SysML activity graph, which carries a context reference to the current SysML model instance; The control token moves along the control flow or object flow connection in the SysML activity graph. When the control token encounters a fork node, the driving engine uses object cloning technology to create multiple copy tokens and pushes the copy tokens to all downstream branches. When a control token or a copy token arrives at an input pin of an action node, a listener check is triggered to check whether all input pins associated with that action node have a token residing there. If so, the listener consumes all tokens associated with the action node for data input and sets the action node's state to be executing; The graph interpretation engine extracts the data carried in the token and encapsulates it into instructions, which are then sent to the simulation execution layer for simulation calculations. After the simulation calculation is completed, the semantic backfilling engine writes the simulation calculation results into the properties of the SysML model instance, and the sandbox sends a signal to the graph interpretation engine that the calculation is complete. After receiving the signal, the graphical explanation engine generates a new data token on the output pin of the action node. This new data token carries the simulation calculation results that have been written into the properties of the SysML model instance. The graph interpretation engine pushes the new data token downstream, triggering the execution of subsequent action nodes.

4. The aero-engine design method based on SysML activity graph native driving and AI autonomous decision-making as described in claim 3, characterized in that, The dynamic pruning based on the sensitivity matrix includes: Construct an AI decision agent and maintain a dynamically updated sensitivity matrix. The elements in the sensitivity matrix are used to represent the approximate values ​​of the partial derivatives of the input parameters of the simulation calculation with respect to the key performance indicators of the output. When a design iteration occurs, the parameter difference vector between the current SysML model instance and the previous version of the SysML model instance is calculated. Based on the sensitivity matrix and parameter difference vector, the expected changes in key performance indicators are calculated. If the expected change in key performance indicators is less than the first preset threshold, the input parameters are determined to be invalid changes. The AI ​​decision agent issues an instruction to skip execution, directly reuses historical results, and skips time-consuming simulation calculations. If the expected change in key performance indicators is greater than or equal to the first preset threshold, the input parameters are determined to be valid changes, and the AI ​​decision agent issues an instruction to execute the simulation, driving the simulation tool to run.

5. The aero-engine design method based on SysML activity graph native driving and AI autonomous decision-making as described in claim 4, characterized in that, The expression for the expected change in the key performance indicator is as follows: ， Where, ΔY j S represents the expected change in the j-th key performance indicator; ij S is an element in the sensitivity matrix. ij This represents the i-th input parameter x. i For every unit change, the target value Y of the j-th key performance indicator... j The resulting pulling force; Δx i These are the components of the parametric difference vector Δx; It is the transpose of the row vector corresponding to the j-th key performance indicator in the sensitivity matrix.

6. The aero-engine design method based on SysML activity graph native driving and AI autonomous decision-making as described in claim 4, characterized in that, The method further includes: After the semantic backfilling engine writes the simulation calculation results into the properties of the SysML model instance, the SysML constraint checker triggers autonomous optimization based on Gaussian process regression when it finds that the key performance indicators exceed the constraints.

7. The aero-engine design method based on SysML activity graph native driving and AI autonomous decision-making as described in claim 6, characterized in that, The autonomous optimization based on Gaussian process regression includes: The AI ​​decision agent reads sample data from the historical version library of SysML models and trains a Gaussian process regression model based on the sample data to fit the nonlinear relationship between input parameters and output. Based on the Gaussian process regression model, the predicted mean and predicted standard deviation of multiple input parameters corresponding to the key performance indicators that exceed the constraints are given; Based on the predicted mean and predicted standard deviation, calculate the expected improvement function corresponding to each input parameter; AI decision-making agents seek the input parameters corresponding to the maximum value in the expected improvement function; The AI ​​decision agent directly calls the SysML API to modify the found input parameters and automatically restarts the simulation calculation process until the constraints are met.

8. The aero-engine design method based on SysML activity graph native driving and AI autonomous decision-making as described in claim 7, characterized in that, The expression for the expected boosting function is: ， Where EI(x) is the expected improvement function; σ(x) is the prediction standard deviation; z represents the standardized improvement space, which measures the extent to which the predicted mean μ(x) is better than the current known best value, and has been adjusted for uncertainty. and These are the cumulative distribution function and probability density function of the standard normal distribution, respectively.

9. The aero-engine design method based on SysML activity graph native driving and AI autonomous decision-making as described in claim 1, characterized in that, The system automatically associates the simulation results with the properties of the SysML model, including: The process-driven engine captures simulation calculation results, builds a Prompt, and feeds it to the locally deployed lightweight LLM. The LLM automatically generates standardized intermediate state JSON format files. Iterate through all empty slots in the SysML model instance. For each empty slot, the system performs multi-dimensional similarity calculations between its metadata and each candidate parameter in the JSON file to obtain the total matching score for each empty slot. If the total matching score exceeds the second preset threshold, a mapping will be automatically established and the values ​​in the JSON file will be filled back into the empty slots corresponding to the total matching score.

10. The aero-engine design method based on SysML activity graph native driving and AI autonomous decision-making according to claim 9, characterized in that, The multi-dimensional similarity calculation includes name semantic similarity calculation, dimensional physical consistency calculation, and structural topological matching calculation.

Images