Multi-body system dynamics intelligent modeling calculation system and method based on natural language

Abstract

The invention discloses a multi-body system dynamics intelligent modeling calculation system and method based on a natural language, and belongs to the field of overall design of spacecrafts. The problems that in the prior art, when the simulation requirement related to extreme working conditions and strong nonlinear coupling is met, the period is long, manual experience is relied on, and the maintenance cost is high are solved. The system comprises a text segmentation embedding unit used for carrying out text segmentation embedding processing on a multi-body dynamics knowledge base and constructing a vectorized dynamics knowledge context; the large language model unit is used for receiving natural language task description input by a user, performing semantic understanding through LLM (Logistics Language Model) and generating a task analysis result according to dynamic knowledge context learning; and the task processing unit is used for classifying the tasks into inquiry tasks, command and control tasks or construction tasks according to the task analysis result, and calling corresponding modules according to LLM and MCP technologies. The method is used in the field of multi-body system dynamics modeling of spacecrafts.

Description

Technical Field

[0001] This invention belongs to the field of spacecraft overall design, and in particular relates to an intelligent modeling and calculation system for multibody system dynamics based on natural language. Background Technology

[0002] Multibody system dynamics analysis is an indispensable core technology foundation for spacecraft overall design and on-orbit mission verification. Its value lies in its ability to accurately predict the mechanical behavior of spacecraft under complex conditions by establishing mathematical models, such as natural frequencies, mode shapes, and load redistribution during orbital maneuvers, attitude adjustments, and on-orbit assembly. This provides crucial basis for configuration optimization, controller parameter tuning, and reliability redundancy design. With the continuous development of aerospace technology, spacecraft configurations are becoming increasingly complex, and the application of advanced mechanisms such as large deployable antennas, solar array hinges, and space robotic arms is becoming increasingly common. In these systems, there are large-scale relative motions and strong flexible coupling effects between components, making traditional dynamic analysis methods based on pure rigid body assumptions unable to reveal the true mechanical behavior of the system. Therefore, it is necessary to establish sophisticated dynamic models that incorporate complex factors such as flexible bodies, hinge nonlinearity, and contact collisions.

[0003] While the importance of high-fidelity multibody dynamics models is widely recognized in the industry, the modeling practice of spacecraft multibody system dynamics has long been constrained by a high-barrier, low-efficiency technical paradigm. This paradigm can be summarized as a linear technical chain of "mechanism formula derivation—code implementation—software integration." In this chain, engineers first need to manually derive complex symbolic equations based on the specific topology of the system. This process not only requires a strong mathematical and mechanical background but is also highly prone to errors. Subsequently, the derived formulas need to be implemented in code using programming languages ​​(such as C++, Fortran, or Python) and further integrated and interface-tested with commercial or self-developed simulation software (such as Adams, Simpack, or self-developed MBDyn).

[0004] This traditional approach has significant inherent drawbacks. First, its iterative efficiency is extremely low, and the cost of exploring design space is exorbitant. For example, during the spacecraft feasibility study phase, even a slight change to the rigid-flexible coupling topology—such as adding a hinge to optimize the antenna deployment path or altering the flexibility of a component to reduce weight—requires a near-complete overhaul of the entire "formula derivation-code implementation" process, requiring the re-deriving of symbolic equations and rewriting of the software interface. This results in iteration cycles lasting weeks or even months, severely hindering design innovation and optimization speed, and making rapid evaluation of multiple configuration options exceptionally difficult. Second, this method leads to fragmented knowledge accumulation. Valuable modeling knowledge, expert experience, and model parameters are scattered across different engineers' personal notes, derivation manuscripts, and specific versions of code, making systematic accumulation, reuse, and inheritance difficult, increasing project risk and human dependency.

[0005] Specifically, existing technologies exhibit significant limitations when addressing simulation requirements involving extreme conditions and strong nonlinear coupling, such as large deployable antennas, on-orbit assembly platforms, and the separation of multiple modules from deep space probes. Due to the cumbersome and lengthy modeling process, it is difficult to conduct rapid and extensive dynamic response assessments for these critical conditions in the early stages of a project. Consequently, some potential engineering risks, such as local resonance caused by modal density, control-structure coupling instability, or mechanism deployment lock-up, often only become apparent later through costly physical testing or even on-orbit failures, leading to substantial development risks and remedial costs. Summary of the Invention

[0006] In view of this, the present invention aims to propose an intelligent modeling and calculation system and method for multibody system dynamics based on natural language, so as to solve the problems of long cycle, reliance on human experience and high maintenance cost of existing technologies when dealing with simulation needs involving extreme working conditions and strong nonlinear coupling.

[0007] To achieve the above objectives, the present invention adopts the following technical solution: A natural language-based intelligent modeling and computational system for multi-body system dynamics, the system comprising: The text segmentation and embedding unit is used to perform text segmentation and embedding processing on the multibody dynamics knowledge base to construct a vectorized dynamics knowledge context. The text segmentation adopts a hybrid segmentation strategy that combines document structure segmentation and recursive character segmentation. The Large Language Model Unit (LLM) is used to receive natural language task descriptions input by users, perform semantic understanding through the Large Language Model (LLM), and generate task analysis results based on dynamic knowledge context learning. The Large Language Model (LLM) uses a pre-trained model and constructs prompt templates based on context examples. The task processing unit classifies tasks into query tasks, command and control tasks, or construction tasks based on task analysis results, and calls the corresponding modules according to the Large Language Model (LLM) and Context Protocol (MCP) technologies: For query tasks, it matches information from simulation results and model configuration files, including material properties, component pose, motion state, constraint state, mass inertia, solution step size, geometric shape, topological configuration, and nodal deformation and displacement, and performs intelligent responses; For command and control tasks, it intervenes in the dynamic simulation in real time through force control module, position control module, gravity module, spring module, camera module, collision module, constraint module, and solver module; For construction tasks, it generates multibody dynamics model configuration files, including rigid body models, flexible body models, and rigid-flexible coupling models, and imports them into the software MBDyn to achieve end-to-end coupled calculations.

[0008] Furthermore, a preferred approach is proposed, wherein the text segmentation and embedding processing constructs a text embedding model based on a Transformer encoder-decoder structure. The Transformer structure calculates the relationship between input vectors through a self-attention mechanism, and the output of the self-attention mechanism is obtained through weighted summation, including: Processing N inputs of dimension D×1 using a self-attention mechanism Each input is transformed into a value vector through a linear transformation:

[0009] in, For bias terms, This is the weight matrix. Given m inputs of dimension D×1; No. Output By calculating attention weights:

[0010] in, Given m inputs of dimension D×1; Indicates the first Each output pair input The level of attention.

[0011] Furthermore, a preferred method is proposed, wherein the attention weight is determined by querying... s and keys The dot product and softmax function are used to obtain:

[0012] in, Indicates key, Indicates the bias term of the query. This represents the weight matrix of the query. Indicates input, This represents the bias term of the key. The weight matrix represents the key weights.

[0013] Furthermore, a preferred approach is proposed, wherein the query task is based on a general query task model, and the necessary descriptive elements include object attributes, constraints, and information types; the object attributes include component number and load number; the constraints include time interval and reference object; and the information types include model state, motion state, and load state.

[0014] Furthermore, a preferred approach is proposed, wherein the command and control task is based on a general command and control task model, and the necessary descriptive elements include object number, payload number, action time, command and control module, and command and control content. Standard instructions are generated through natural language parsing to control the simulation state in real time.

[0015] Furthermore, a preferred method is proposed, in which the rigid body model is imported through a JSON format parameter library or URDF file in the construction task. The URDF file describes the linkage and joint structure and adds rigid body angle-driven hinge, angular velocity-driven hinge or ball joint constraint method; the flexible body model is processed through the msh file generated by Gmsh software and the node mesh is constructed based on the absolute node coordinate method.

[0016] Furthermore, a preferred method is proposed, wherein the construction of the flexible body model includes parsing the MeshFormat, Nodes, and Elements segments of the msh file, calculating the unit gradient information from the node coordinates, and defining the dynamic behavior of the flexible body.

[0017] Based on the same inventive concept, this invention also proposes an intelligent modeling and calculation method for the dynamics of multi-body systems based on natural language, the method comprising: Text segmentation and embedding are performed on the multibody dynamics knowledge base to construct a vectorized dynamics knowledge context. The text segmentation adopts a hybrid segmentation strategy that combines document structure segmentation and recursive character segmentation. The system receives a natural language task description input by the user, performs semantic understanding through a large language model (LLM), and generates task analysis results based on dynamic knowledge context learning. The large language model (LLM) uses a pre-trained model and constructs prompt templates based on context examples. Based on the task analysis results, the tasks are categorized into inquiry tasks, accusation tasks, or construction tasks, and the corresponding modules are called according to the Large Language Model (LLM) Context Protocol (MCP) technology. For query tasks, information is matched from simulation results and model configuration files, including material properties, component pose, motion state, constraint state, mass inertia, solution step size, geometric shape, topological configuration, and nodal deformation and displacement, and intelligent responses are provided. For command and control tasks, dynamic simulation is intervened in real time through force control module, position control module, gravity module, spring module, camera module, collision module, constraint module and solver module; For the construction task, a multibody dynamics model configuration file is generated, including rigid body model, flexible body model and rigid-flexible coupling model, and imported into the software MBDyn to realize end-to-end coupling calculation.

[0018] Based on the same inventive concept, the present invention also proposes a computer device, including a memory and a processor, wherein the memory stores a computer program, and when the processor runs the computer program stored in the memory, the processor executes an intelligent modeling and calculation method for multi-body system dynamics based on natural language as described above.

[0019] Based on the same inventive concept, the present invention also proposes a computer-readable storage medium storing a computer program, which, when executed by a processor, performs the steps of the above-described intelligent modeling and calculation method for multibody system dynamics based on natural language.

[0020] Compared with the prior art, the beneficial effects of the present invention are: Traditional methods heavily rely on engineers manually deriving symbolic equations and writing code, resulting in high professional barriers and long iteration cycles in the modeling process. This invention introduces a Large Language Model (LLM) as the core intelligent engine, achieving a paradigm shift from code-driven to natural language-driven approaches. This shift enables engineers with different backgrounds—such as general engineers, attitude control engineers, structural engineers, and mechanism engineers—to interact using a unified natural language and iterate in real time at the same semantic level. This completely eliminates communication barriers and conversion costs caused by professional differences and tool variations, shortening the traditional "solution-simulation-evaluation" closed-loop cycle by an order of magnitude, and significantly improving the efficiency and breadth of design space exploration.

[0021] In traditional manual modeling, engineers often have to simplify complex microscopic physical mechanisms (such as the dynamic characteristics of aerospace-grade flexible attachments, hinge gaps, and contact collision nonlinearities) in pursuit of efficiency, inevitably introducing a loss of fidelity. This invention embeds domain-specific knowledge (such as the self-developed software user manual, common example sets, and basic principles of dynamics) into the LLM's knowledge base and physical consistency verification module. Based on the user's task description, it can automatically match and call high-fidelity mechanistic models. This system does not simply understand language; instead, it associates language instructions with verified domain knowledge, thereby ensuring the engineering reliability of simulation results while automatically generating models, achieving a synergistic effect of both speed and accuracy.

[0022] In the spacecraft development process, the later a problem is discovered, the higher the cost of correction. Traditional methods, due to their low modeling efficiency, struggle to rapidly assess the coupled dynamics response of numerous extreme conditions (such as the deployment of large deployable antennas, docking of on-orbit assembly platforms, and separation of multiple modules from deep space probes) in the early stages of project initiation. This invention allows engineers to quickly build and simulate various extreme conditions during the design phase through intuitive language interaction, thereby exposing potential risks such as local resonance caused by modal density, control-structure coupling instability, and mechanism deployment lock-up in advance. This risk-awareness capability enables design optimization and decision-making to proceed earlier, effectively reducing the number of costly physical tests and on-orbit fault correction costs in the later stages, and thus lowering the overall development risk.

[0023] This invention is not a simple application of the general large language model LLM, but rather a dedicated intelligent processing pipeline designed for the specific needs of the vertical field of multibody dynamics. This pipeline begins with a hybrid text segmentation and embedding strategy for engineering documents, combining document structure chunking and recursive character chunking to ensure that domain knowledge is efficiently and accurately vectorized. Furthermore, to address the diversity of dynamics tasks, a divide-and-conquer task processing architecture is designed: complex user requirements are decomposed into three types of atomic tasks: query, accusation, and construction, with dedicated processing modules and metadata models (such as necessary descriptive element tables) designed for each type of task. This collaborative architecture allows the system to delve into the details of each task type. For example, the construction module can specifically handle the conversion from URDF files to MBDyn models and extend constraint types, thus achieving a depth of specialization on top of generality—something existing general-purpose simulation software or basic language interfaces lack.

[0024] The intelligent modeling and calculation system and method for multibody system dynamics proposed in this invention are applied to the field of multibody system dynamics modeling for spacecraft. Attached Figure Description

[0025] The accompanying drawings, which form part of this invention, are used to provide a further understanding of the invention. The illustrative embodiments of the invention and their descriptions are used to explain the invention and do not constitute an undue limitation of the invention. In the drawings: Figure 1 This is a flowchart of an intelligent modeling and calculation system for multi-body system dynamics based on natural language, as described in this invention. Figure 2 This is a flowchart of the text segmentation and embedding process described in this invention; Figure 3 This is a flowchart of the input instruction analysis and processing described in this invention; Figure 4 This is a schematic diagram comparing the modeling errors of the intelligent platform described in this invention with those of manual modeling; Figure 5 This is a schematic diagram of the modeling of a seven-degree-of-freedom robotic arm on the intelligent modeling platform described in this invention. Detailed Implementation

[0026] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. It should be noted that, unless otherwise specified, the embodiments and features in the embodiments of the present invention can be combined with each other, and the described embodiments are only some embodiments of the present invention, not all embodiments.

[0027] Implementation Method 1: This implementation method addresses the problem that traditional methods heavily rely on engineers manually deriving symbolic equations and writing code, leading to high professional barriers and long iteration cycles in the modeling process. It proposes an intelligent modeling and computation system for multi-body system dynamics based on natural language. The system includes: The text segmentation and embedding unit is used to perform text segmentation and embedding processing on the multibody dynamics knowledge base to construct a vectorized dynamics knowledge context. The text segmentation adopts a hybrid segmentation strategy that combines document structure segmentation and recursive character segmentation. The Large Language Model Unit (LLM) is used to receive natural language task descriptions input by users, perform semantic understanding through the Large Language Model (LLM), and generate task analysis results based on dynamic knowledge context learning. The Large Language Model (LLM) uses a pre-trained model and constructs prompt templates based on context examples. The task processing unit classifies tasks into query tasks, command and control tasks, or construction tasks based on task analysis results, and calls the corresponding modules according to the Large Language Model (LLM) and Context Protocol (MCP) technologies: For query tasks, it matches information from simulation results and model configuration files, including material properties, component pose, motion state, constraint state, mass inertia, solution step size, geometric shape, topological configuration, and nodal deformation and displacement, and performs intelligent responses; For command and control tasks, it intervenes in the dynamic simulation in real time through force control module, position control module, gravity module, spring module, camera module, collision module, constraint module, and solver module; For construction tasks, it generates multibody dynamics model configuration files, including rigid body models, flexible body models, and rigid-flexible coupling models, and imports them into the software MBDyn to achieve end-to-end coupled calculations.

[0028] Existing technologies are essentially program calls based on predefined rules and fixed inputs and outputs (such as GUI operations or script API calls). The technical principle of the system proposed in this implementation is to construct an intelligent agent capable of dynamically understanding and executing user intentions. Its core is a task interpretation mechanism based on large-scale domain knowledge context learning. The system first associates unstructured natural language input with a carefully constructed and vectorized dynamics knowledge base through retrieval-enhanced generation technology, providing rich domain context for the LLM. Then, the large language model LLM does not engage in general dialogue, but rather performs structured parsing of user input based on a pre-defined task meta-model (such as the definition and necessary descriptive elements of query tasks, command tasks, and construction tasks), accurately identifying the user's true operational intentions (such as querying the displacement of a component at a specific moment, applying a force control command, or constructing a specific rigid-flexible coupling model), thereby transforming ambiguous natural language descriptions into precise, executable engineering instructions.

[0029] Unlike existing technologies where software functions are fixed, this implementation method creatively solves the structured interaction problem between large language models (LLMs) and professional simulation tools (such as the self-developed MBDyn software) by introducing the Model Context Protocol (MCP), an open and standardized protocol. The MCP protocol acts as a universal adapter between the "intelligent brain" and the "professional hands and feet." Through a standardized resource and tool description mechanism, it enables the large language model (LLM) to dynamically discover, invoke, and securely execute the functions of external modules (such as query modules, command modules, and build modules) without embedding specific API documentation into the model parameters. This principle gives the system high scalability and flexibility; new dynamic models, simulation functions, or control modules can be easily integrated into this framework without refactoring the core intelligent engine.

[0030] The system proposed in this embodiment is not a simple application of the general large language model LLM, but rather a dedicated intelligent processing pipeline designed for the specific needs of the vertical domain of multibody dynamics. This pipeline begins with a hybrid text segmentation and embedding strategy for engineering documents, combining document structure chunking and recursive character chunking to ensure that domain knowledge is efficiently and accurately vectorized. Furthermore, to address the diversity of dynamics tasks, a divide-and-conquer task processing architecture is designed: complex user requirements are decomposed into three types of atomic tasks: query, command, and construction, with dedicated processing modules and metadata models (such as necessary descriptive element tables) designed for each type of task. This "division of labor and cooperation" architecture allows the system to delve into the details of each type of task. For example, the construction module can specifically handle the conversion from URDF files to MBDyn models and extend constraint types, thereby achieving a professional depth on the basis of generality, which is not available in existing general simulation software or basic language interaction interfaces.

[0031] Implementation Method 2: This implementation method proposes an intelligent modeling and calculation method for multi-body system dynamics based on natural language. The method includes: Text segmentation and embedding are performed on the multibody dynamics knowledge base to construct a vectorized dynamics knowledge context. The text segmentation adopts a hybrid segmentation strategy that combines document structure segmentation and recursive character segmentation. The system receives a natural language task description input by the user, performs semantic understanding through a large language model (LLM), and generates task analysis results based on dynamic knowledge context learning. The large language model (LLM) uses a pre-trained model and constructs prompt templates based on context examples. Based on the task analysis results, the tasks are categorized into inquiry tasks, accusation tasks, or construction tasks, and the corresponding modules are called according to the Large Language Model (LLM) Context Protocol (MCP) technology. For query tasks, information is matched from simulation results and model configuration files, including material properties, component pose, motion state, constraint state, mass inertia, solution step size, geometric shape, topological configuration, and nodal deformation and displacement, and intelligent responses are provided. For command and control tasks, dynamic simulation is intervened in real time through force control module, position control module, gravity module, spring module, camera module, collision module, constraint module and solver module; For the construction task, a multibody dynamics model configuration file is generated, including rigid body model, flexible body model and rigid-flexible coupling model, and imported into the software MBDyn to realize end-to-end coupling calculation.

[0032] Implementation Method 3: This implementation method proposes a computer device, including a memory and a processor. The memory stores a computer program. When the processor runs the computer program stored in the memory, the processor executes a multi-body system dynamics intelligent modeling and calculation method based on natural language as described in Implementation Method 2.

[0033] Implementation Method 4: This implementation method also proposes a computer-readable storage medium storing a computer program, which, when executed by a processor, performs the steps of the intelligent modeling and calculation method for multi-body system dynamics based on natural language as described in Implementation Method 2.

[0034] Implementation Method 5, see below Figures 1 to 5 This embodiment describes a specific implementation of the intelligent modeling and computation system for multi-body system dynamics based on natural language described in Embodiment 1. The system includes: The text segmentation and embedding unit is used to perform text segmentation and embedding processing on the multibody dynamics knowledge base to construct a vectorized dynamics knowledge context. The text segmentation adopts a hybrid segmentation strategy that combines document structure segmentation and recursive character segmentation. The Large Language Model Unit (LLM) is used to receive natural language task descriptions input by users, perform semantic understanding through the Large Language Model (LLM), and generate task analysis results based on dynamic knowledge context learning. The Large Language Model (LLM) uses a pre-trained model and constructs prompt templates based on context examples. The task processing unit classifies tasks into query tasks, command and control tasks, or construction tasks based on task analysis results, and calls the corresponding modules according to the Large Language Model (LLM) and Context Protocol (MCP) technologies: For query tasks, it matches information from simulation results and model configuration files, including material properties, component pose, motion state, constraint state, mass inertia, solution step size, geometric shape, topological configuration, and nodal deformation and displacement, and performs intelligent responses; For command and control tasks, it intervenes in the dynamic simulation in real time through force control module, position control module, gravity module, spring module, camera module, collision module, constraint module, and solver module; For construction tasks, it generates multibody dynamics model configuration files, including rigid body models, flexible body models, and rigid-flexible coupling models, and imports them into the software MBDyn to achieve end-to-end coupled calculations.

[0035] In practical applications, while Large Language Models (LLMs) possess strong generalization capabilities, the accuracy of their generated information in specific vertical domains is often limited by the "illusion" phenomenon. To improve their performance in vertical domains, the model needs to learn knowledge relevant to that domain; however, the size of the knowledge base is limited by the context window of the large language model. Therefore, text segmentation and embedding processing of the corresponding knowledge base is necessary to improve the model's understanding and generation capabilities for specific domains, such as... Figure 2 As shown: Text segmentation and embedding first requires breaking down large blocks of text into smaller segments, which improves the accuracy of content retrieved from the vector database. This implementation employs a hybrid segmentation strategy combining document structure segmentation and recursive character segmentation, including: firstly, dividing the text content according to logical blocks, such as HTML... ， ， Tags, Markdown headings # and ##, are used to initially divide enterprise documents in formats such as Word, PDF, and HTML according to document structure information. At this point, the lengths of the text segments may vary greatly, which is not conducive to subsequent encoding analysis. Therefore, a recursive character block segmentation method is used to further divide larger text blocks. The minimum length len of the initially divided text block is used as the segmentation criterion, and the blocks are divided from high to low according to the priority of the delimiter. Text blocks that do not reach len are padded with zeros.

[0036] After obtaining the text segmentation results, a text embedding model is constructed based on the Transformer encoder-decoder structure. The Transformer structure uses a self-attention mechanism to represent the relationships between words at different positions in the text. By parallelizing multiple self-attention mechanisms, multi-dimensional correlation information between the inputs is obtained. (Self-attention module) deal with Each dimension is Input and output Each input consists of two vectors of the same size. In natural language processing, each input corresponds to a word or a part of a word. First, a set of corresponding "values" is calculated for each input: (1) in, These represent the bias term and the weight matrix, respectively.

[0037] Next, the Output By weighting all values We get the following by weighted summation: (2) scalar weights here Indicates the first Each output pair input The level of attention. To calculate the level of attention, the input needs to undergo two additional linear transformations: (3) here q n and k m Let represent the query and the key, respectively. Then, we calculate the dot product between the query and the key and process the results using the softmax function: (4) in, Indicates key, Indicates the bias term of the query. This represents the weight matrix of the query. Indicates input, This represents the bias term of the key. The weight matrix represents the key weights.

[0038] In-context learning (ICL) refers to enabling a model to learn and adapt to new tasks directly during inference by providing contextual examples without updating model parameters. The key to ICL lies in effectively constructing these contextual examples. Typically, by providing a series of examples similar to the target task (including input and expected output), the model can be guided to understand the task requirements and generate expected results. This approach can be viewed as a form of implicit learning, where the model infers the output of a new input based on patterns in the contextual examples. This implementation uses dynamics expertise as external knowledge for the question-answering system—a data resource outside the model—to provide rich and factual supporting information to assist in generating intelligent interpretation results. To enhance the fluency and diversity of responses, a pre-trained large language model can be used to construct prompt learning templates. The retrieved knowledge and user questions can be concatenated as input prompts, and training can improve the model's ability to utilize external knowledge within the templates.

[0039] This implementation uses the Qwen3-14B large language model, open-sourced by Alibaba Cloud's Tongyi Lab, to construct examples using raw data related to multibody dynamics. An ICL (Independent Language Control) approach is used to construct a prompt based on the examples and raw inputs. The carefully designed prompt is then used as model input to obtain the final output. The system proposed in this implementation is oriented towards spacecraft multibody system dynamics models and serves users. Commonly used dynamics task statements are organized and analyzed, categorized into query tasks, command and control tasks, and construction tasks. For query tasks, user-input keywords are matched against massive amounts of data in the simulation system to obtain user query information from rigid body pose, motion state, material properties, constraint state, load state, topological configuration, and flexible body deformation, and intelligent responses are provided. For command and control tasks, user input is decomposed according to a controlled language template to obtain standard command forms, which are then used as command and control inputs to the simulation system. Force control, position control, constraint, collision, camera, spring, gravity, and solver modules intervene in the simulation in real time. For the construction task, a knowledge base is retrieved based on user input, and the retrieved knowledge is fed into the large language model LLM together with the input to construct a dynamic model of a rigid-flexible coupled multibody system.

[0040] After the user inputs their task requirements, the large language model analyzes and processes their instruction features. Based on the task type, it learns relevant knowledge from the dynamic knowledge base and calls the corresponding module to solve the task requirements based on Model Context Protocol (MCP) technology. The processing flow is as follows: Figure 3 As shown. MCP is an open, standardized protocol whose core function is to provide a structured interface for large language models to interact with external data sources and tools. This protocol, through defining a standardized resource and tool description mechanism, enables models to dynamically discover, invoke, and securely execute external procedural operations without embedding specific API documentation.

[0041] The query task refers to a user using natural language to ask for the required information. The large language model calls the query module to perform matching and searching from the massive information in the simulation results and model configuration files. It obtains the user's query information from material properties, component pose, motion state, constraint state, mass inertia, solution step size, geometric shape, topological configuration, and nodal deformation displacement, and provides intelligent responses. The model configuration file contains intrinsic characteristics such as material properties, constraint types, input / output order and type, and initial component pose; the simulation results contain state responses such as constraint force changes, component pose changes, solution step size, simulation time, and flexible body deformation. To achieve unified management of the above massive information, it is first necessary to construct a general query task model that can cover its information characteristics. Through the analysis of the potential differences in the above information, the necessary descriptive elements required for obtaining different information are summarized, as shown in Table 1.

[0042] Table 1. Essential descriptive elements for the inquiry task

[0043] The command and control task refers to the user adding, subtracting, or changing the input to the dynamics simulation using natural language. The large language model calls the command and control module to intervene in the dynamics simulation based on the natural language input. The command and control module includes a force control module, a position control module, a gravity module, a spring module, a camera module, a collision module, a constraint module, and a solver module, which can intervene in the dynamics simulation in real time. The input statements for the command and control task usually have a clear target, mode of action, time of action, and command content. Similarly, a general command and control task model covering information features is constructed, and the necessary descriptive elements required for different command and control commands are summarized, as shown in Table 2.

[0044] Table 2 Essential Descriptive Elements of the Charge and Duty Mission

[0045] The construction task refers to the user describing the composition of the dynamic model using natural language. The large language model calls the construction module to generate the dynamic model configuration file based on the input. Dynamic models are divided into rigid body models, flexible body models, and rigid-flexible coupling models. Rigid body models are further divided into pre-configured rigid body models and custom rigid body models. For dynamic models with simple topologies, users can refer to the JSON format to build a rigid body parameter information library. The construction module reads parameters such as position, geometry, mass, inertia, and material properties from the information library and imports them into the self-developed software MBDyn to generate the corresponding dynamic model. For dynamic models with complex topologies, users can use a Solidworks plugin to convert commonly used 3D model files such as STP and STL into URDF files. URDF stands for Unified Robot Description Format, a format based on XML specifications used to describe robot structures. A robot mainly consists of links and joints. Links are rigid bodies with mass properties, while joints are structures that connect and restrict the relative motion of two rigid bodies, also known as kinematic pairs. Connecting links sequentially through joints forms a series of kinematic chains. A URDF document describes the relative relationships, inertial properties, geometric characteristics, and collision models of a series of joints and links. The build module can import information such as relative poses and constraint methods from URDF files into MBDyn, adding rigid body angle-driven hinges, angular velocity-driven hinges, and ball joints to the existing joint types in URDF, supporting the construction of complex and diverse rigid body dynamics models. Flexible body models can be processed by Gmsh software and exported as MSH files. MSH files consist of several sections, including MeshFormat, Nodes, and Elements sections. The MeshFormat data block, located at the beginning of the MSH file, primarily stores the basic data of the finite element mesh and the storage type used. The Nodes section defines the number of nodes and the coordinates of each node. The Elements section mainly stores information such as the numbering, geometric boundary conditions, and physical component information of the model's points, lines, surfaces, and volumes. The build module reads the node mesh information from the analysis file, calculates the element gradient information based on the node poses, and thus constructs a flexible body dynamics model based on the absolute node coordinate method. A general construction task model that can include construction information features is constructed, and the necessary descriptive elements required for different construction tasks are summarized as shown in Table 3.

[0046] Table 3. Essential descriptive elements for constructing the task

[0047] The technical process of the intelligent modeling and calculation system for multibody system dynamics is as follows: A dynamics knowledge base was constructed based on a set of commonly used calculation examples, the user manual of the self-developed software, and basic dynamics knowledge, and then the knowledge base was processed by text segmentation and embedding. After the user inputs their modeling requirements, the system matches relevant knowledge from the knowledge base based on their inherent information and constructs a prompt according to a carefully designed prompt word template as input to the large language model. Large language models analyze input information and perform task classification; Based on the classification results, the query module, command module, or construction module is invoked to complete the corresponding task. The query module is used to respond with dynamic information related to the task, the command module is used to control and change the state related to the dynamic simulation, and the construction module is used to build multi-rigid-body dynamic models, multi-flexible-body dynamic models, and rigid-flexible coupling dynamic models according to requirements.

[0048] A schematic diagram of a seven-degree-of-freedom robotic arm constructed by an intelligent modeling platform is shown below. Figure 5 As shown, the error comparison between intelligent platform modeling and manual modeling is as follows: Figure 4 As shown, it can be seen that the present invention reduces the modeling time by at least 10 times compared to existing methods.

[0049] Those skilled in the art will understand that embodiments of this disclosure can be provided as methods, systems, or computer program products. Therefore, this disclosure can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this disclosure can take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0050] This disclosure is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this disclosure. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create a machine for implementing the flowchart illustrations and / or block diagrams. Figure 1 One or more processes and / or boxes Figure 1 The computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to operate in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes. These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0051] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of this disclosure and not to limit its protection scope. Although this disclosure has been described in detail with reference to the above embodiments, those skilled in the art should understand that after reading this disclosure, they can still make various changes, modifications or equivalent substitutions to the specific implementation of the invention, but these changes, modifications or equivalent substitutions are all within the protection scope of the published pending claims.

Claims

1. A multi-body system dynamics intelligent modeling and computation system based on natural language, characterized in that, The system includes: The text segmentation and embedding unit is used to perform text segmentation and embedding processing on the multibody dynamics knowledge base to construct a vectorized dynamics knowledge context. The text segmentation adopts a hybrid segmentation strategy that combines document structure segmentation and recursive character segmentation. The Large Language Model Unit (LLM) is used to receive natural language task descriptions input by users, perform semantic understanding through the Large Language Model (LLM), and generate task analysis results based on dynamic knowledge context learning. The Large Language Model (LLM) uses a pre-trained model and builds prompt templates based on context examples. The task processing unit classifies tasks into query tasks, command and control tasks, or construction tasks based on task analysis results, and calls the corresponding modules according to the Large Language Model (LLM) and Context Protocol (MCP) technologies: For query tasks, it matches information from simulation results and model configuration files, including material properties, component pose, motion state, constraint state, mass inertia, solution step size, geometric shape, topological configuration, and nodal deformation and displacement, and performs intelligent responses; For command and control tasks, it intervenes in the dynamic simulation in real time through force control module, position control module, gravity module, spring module, camera module, collision module, constraint module, and solver module; For construction tasks, it generates multibody dynamics model configuration files, including rigid body models, flexible body models, and rigid-flexible coupling models, and imports them into the software MBDyn to achieve end-to-end coupled calculations.

2. The intelligent modeling and calculation system for multi-body system dynamics based on natural language as described in claim 1, characterized in that, The text segmentation and embedding process is based on a Transformer encoder-decoder structure to construct a text embedding model. The Transformer structure calculates the relationship between input vectors through a self-attention mechanism, and the output of the self-attention mechanism is obtained through weighted summation, including: Processing N inputs of dimension D×1 using a self-attention mechanism Each input is transformed into a value vector through a linear transformation: in, For bias terms, This is the weight matrix. Given m inputs of dimension D×1; No. Output By calculating attention weights: in, Given m inputs of dimension D×1; Indicates the first Each output pair input The level of attention.

3. The intelligent modeling and calculation system for multi-body system dynamics based on natural language as described in claim 2, characterized in that, The attention weight is obtained through querying. s and keys The dot product and softmax function are used to obtain: in, As key, For the bias term of the query, For the weight matrix of the query, For input, For the bias term of the key, Let be the weight matrix of the keys.

4. The intelligent modeling and calculation system for multi-body system dynamics based on natural language as described in claim 1, characterized in that, The query task is based on a general query task model. The necessary descriptive elements include object attributes, constraints, and information types. Object attributes include component number and load number. Constraints include time interval and reference object. Information types include model state, motion state, and load state.

5. The intelligent modeling and calculation system for multi-body system dynamics based on natural language according to claim 1, characterized in that, The command and control task is based on a general command and control task model. The necessary descriptive elements include object number, payload number, action time, command and control module, and command and control content. Standard instructions are generated through natural language parsing to control the simulation status in real time.

6. The intelligent modeling and calculation system for multi-body system dynamics based on natural language according to claim 1, characterized in that, In the construction task, the rigid body model is imported through a JSON format parameter library or URDF file. The URDF file describes the linkage and joint structure and adds rigid body angle-driven hinges, angular velocity-driven hinges, or ball joint constraints. The flexible body model is processed through an msh file generated by Gmsh software, and a node mesh is constructed based on the absolute node coordinate method.

7. The intelligent modeling and calculation system for multi-body system dynamics based on natural language according to claim 1, characterized in that, The construction of the flexible body model includes parsing the MeshFormat, Nodes, and Elements segments of the msh file, calculating the unit gradient information from the node coordinates, and defining the dynamic behavior of the flexible body.

8. A method for intelligent modeling and computation of multi-body system dynamics based on natural language, characterized in that, The method is implemented based on the system described in any one of claims 1 to 7, and the method includes: Text segmentation and embedding are performed on the multibody dynamics knowledge base to construct a vectorized dynamics knowledge context; It receives a natural language task description input by the user, performs semantic understanding through a large language model (LLM), and generates task analysis results based on dynamic knowledge context learning. Based on the task analysis results, the tasks are categorized into inquiry tasks, accusation tasks, or construction tasks, and the corresponding modules are called according to the Large Language Model (LLM) Context Protocol (MCP) technology. For query tasks, information is matched from simulation results and model configuration files, and intelligent responses are provided; For command and control tasks, dynamic simulation is intervened in real time through force control module, position control module, gravity module, spring module, camera module, collision module, constraint module and solver module; For the construction task, a multibody dynamics model configuration file is generated and imported into the software MBDyn to achieve end-to-end coupled calculation.

9. A computer device, characterized in that: It includes a memory and a processor, wherein the memory stores a computer program, and when the processor runs the computer program stored in the memory, the processor executes the intelligent modeling and calculation method for multibody system dynamics based on natural language as described in claim 8.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program that, when executed by a processor, performs the steps of the intelligent modeling and calculation method for multibody system dynamics based on natural language as described in claim 8.

Images