A sysml model-driven automated simulation script processing system and method

Abstract

The application provides a SysML model driven automatic simulation script processing system and method, relates to the technical field of SysML model driven simulation, and comprises a user interactive interface / script editor, a script analysis and execution engine, a SysML model data interaction encapsulation library, a core operation and self-defined function library, a SysML modeling tool interface, an external simulation and communication interface and model data storage. The application establishes a tool chain with model-simulation bidirectional mapping, complex logic automatic processing and heterogeneous environment adaptive integration capabilities.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of SysML model-driven simulation, in particular to a SysML model-driven automatic simulation script processing system and method. BACKGROUND

[0002] Under the background of the deep integration of digital twinning and intelligent manufacturing, the design and verification of complex systems are facing unprecedented challenges. The characteristics of multi-field physical coupling and real-time dynamic interaction make it difficult for traditional development modes to meet the accuracy and efficiency requirements of system engineering. Under this background, model-driven engineering (MDE) and systems modeling language (SysML) have become the core technical support for system life cycle management due to their structured modeling advantages.

[0003] However, as the complexity of systems grows exponentially, SysML models have exposed significant limitations in the simulation verification link. Although existing modeling tools have powerful visual modeling capabilities, they expose serious integration barriers when interfacing with external high-performance simulation platforms, real-time data interfaces, and distributed simulation architectures. For example, in multi-physical field coupling simulation, parsing massive input parameters from SysML parameter models, dynamically configuring simulation conditions, capturing model state variables in real time, and high-frequency data interaction with data distribution service (DDS) based real-time systems often rely on a large number of manual operations and customized script development. In addition, in the face of scenarios involving random process modeling and complex numerical calculation, traditional tools lack flexible scripting control capabilities, making it difficult to automate the simulation verification process, greatly hindering the system iteration optimization process.

[0004] Therefore, it is necessary to optimize SysML models and establish a tool chain with model-simulation bidirectional mapping, complex logic automation processing, and heterogeneous environment adaptive integration capabilities to achieve seamless conversion of SysML models from design space to physical space. SUMMARY

[0005] The purpose of the present application is to provide a SysML model-driven automatic simulation script processing system and method, which establishes a tool chain with model-simulation bidirectional mapping, complex logic automation processing, and heterogeneous environment adaptive integration capabilities.

[0006] The present application is implemented by the following technical solutions:

[0007] A SysML model-driven automatic simulation script processing system, comprising:

[0008] A user interaction interface / script editor is used to provide an environment for users to write, edit, debug and execute custom C#-based simulation scripts;

[0009] A script parsing and execution engine is used to parse the simulation script and convert it into executable instructions;

[0010] A SysML model data interaction encapsulation library encapsulates the underlying API of the SysML modeling tool based on the C# language and is used to read and write SysML model data;

[0011] A core operation and custom function library is used to predefine C# language script functions and modules;

[0012] A SysML modeling tool interface is used to access and modify SysML model data;

[0013] An external simulation and communication interface is used to exchange data and control with external simulation tools, real-time systems or distributed DDS networks;

[0014] Model data storage is used to realize persistent storage of SysML model files.

[0015] Preferably, the C# language script functions and modules include general mathematical functions, statistical and random number generation functions, input / output and log functions, simulation time and signal management functions, external program set dynamic loading and method calling functions, data distribution service communication functions, simulation interface functions and external data source interaction functions.

[0016] The application also provides a SysML model driven automated simulation script processing method, which is realized based on the above-mentioned SysML model driven automated simulation script processing system and includes the following steps:

[0017] Obtaining a simulation script, wherein the simulation script is a SysML model element bound simulation logic code written in a programming language;

[0018] Performing lexical analysis on the simulation script to obtain a Token sequence;

[0019] Performing semantic conversion on the Token sequence to realize mapping of semantic information to corresponding functions;

[0020] Extracting and analyzing parameters;

[0021] Integrating the results of semantic conversion and the analyzed parameters to generate a compilable source code text;

[0022] Performing parsing dependency and compilation based on the source code text to obtain an executable program set;

[0023] Generating a simulation instance based on the executable program set.

[0024] Preferably, the method for writing the simulation script is:

[0025] The simulation logic code bound with the SysML model element is written using languages such as C#, and the bidirectional mapping between the simulation script and the SysML model is realized through the feature tag.

[0026] Preferably, the method for performing lexical analysis on the simulation script is:

[0027] The simulated script is scanned character by character using the lexical analyzer Lexer of CSharpSyntaxTree, and the continuous character stream is divided into multiple Tokens, each Token representing a syntax unit in the script.

[0028] The information of each Token is recorded, including type, value, and location information in the simulation script.

[0029] The Token sequence is formed by multiple Tokens and corresponding information.

[0030] Preferably, the method for performing semantic conversion on the Token sequence is:

[0031] The nodes of the syntax tree are traversed to identify and extract various key semantic elements, including custom function calls, specific variables and constants, and special operators and language constructs.

[0032] At least one dictionary is defined to store the mapping relationship between the key semantic elements and the code fragments or functions in the simulated script.

[0033] Preferably, the method for extracting and parsing parameters is:

[0034] Based on the simulation script, various attributes are extracted and associated with variables or parameters.

[0035] Format checking and dependency checking are performed to ensure that the data meets the requirements of the simulation logic.

[0036] Preferably, the method for performing the dependency analysis based on the source code text is:

[0037] The source code text is scanned to identify the program set DLLs.

[0038] All program set DLLs are dynamically loaded, and the corresponding using reference is added in the source code text.

[0039] Preferably, the method for performing the compilation based on the source code text is:

[0040] The source code text is converted into intermediate language instructions in real time;

[0041] The intermediate language instructions are used to generate an executable assembly for direct running, forming the executable assembly.

[0042] Preferably, the method for generating a simulation instance based on the executable assembly is:

[0043] The executable assembly is loaded into memory by using the reflection mechanism of.NET;

[0044] The simulation instance is dynamically created from the loaded executable assembly by using the Assembly.CreateInstance method.

[0045] The technical solution of the present application has at least the following advantages and beneficial effects:

[0046] The present application greatly optimizes the SysML modeling process by introducing a simulation script, realizes automatic extraction of input required for simulation, intelligent configuration of simulation environment, and automatic writing of simulation results to the model, significantly reduces the complexity of simulation operation, and shortens the simulation iteration period by more than 50%;

[0047] The script capability of the present application is built-in rich mathematical and statistical functions, and also supports dynamic loading of external C# assemblies, which can realize complex numerical calculation, in-depth statistical analysis and execution of custom algorithms directly in the model through the script, greatly simplifies the data processing process, and integrates advanced computing capability directly into the model logic;

[0048] The present application supports the native support of DDS and UDP communication protocols through the simulation script, and the SysML model can realize real-time and efficient bidirectional data interaction with external tools, distributed simulation environment and hardware-in-the-loop platform, and further realize traditional integration barriers, so that the model and the actual running environment are more closely integrated;

[0049] The simulation script of the present application can be deeply integrated with mainstream data tools such as Excel, and further can realize one-key import of simulation parameters, facilitating rapid initialization of simulation from external data sources; at the same time, the simulation results can also be efficiently exported to Excel or other compatible formats, greatly simplifying the data analysis, report generation and collaboration process among teams, and ensuring smooth circulation and efficient utilization of simulation data;

[0050] Based on the powerful encapsulation capability of C# language and the dynamic loading mechanism of the script, the present application accelerates the development process of domain-specific simulation solutions, promotes the reuse of knowledge and functions, and is helpful to realize rapid construction and reuse of complex simulation components;

[0051] The present application reduces the learning curve of high-level simulation automation by abstracting the underlying complex API and communication protocols into intuitive and easy-to-use script commands. BRIEF DESCRIPTION OF DRAWINGS

[0052] Figure 1 A flowchart of a SysML model-driven automated simulation script processing method provided for embodiment 2 of the present application is shown in FIG. 2.

[0053] Figure 2 A principle diagram of an implementation case of the SysML model-driven automated simulation script processing method provided for embodiment 2 of the present application is shown in FIG. 3.

[0054] Figure 3 A flowchart of a user's actual simulation process provided for embodiment 2 of the present application is shown in FIG. 4. DETAILED DESCRIPTION

[0055] To make the objectives, technical solutions and advantages of the embodiments of the present application clearer, the technical solutions in the embodiments of the present application will be described below in connection with the drawings in the embodiments of the present application. Obviously, the described embodiments are some embodiments of the present application, but not all the embodiments of the present application. The components of the embodiments of the present application described and shown in the drawings herein can be arranged and designed in various different configurations.

[0056] Embodiment 1

[0057] The present embodiment provides a SysML model-driven automated simulation script processing system, comprising:

[0058] A user interaction interface / script editor, configured to provide an environment for a user to write, edit, debug and execute a custom C# language-based simulation script;

[0059] A script parsing and execution engine, configured to parse the simulation script and convert it into executable instructions;

[0060] A SysML model data interaction encapsulation library, encapsulating the underlying API of a SysML modeling tool based on C# language, configured to read and write SysML model data;

[0061] A core operation and custom function library, configured to predefine C# language script functions and modules;

[0062] A SysML modeling tool interface, configured to access and modify SysML model data;

[0063] An external simulation and communication interface, configured to exchange data and control with external simulation tools (such as MATLAB / Simulink, Modelica simulator, etc.), real-time systems or distributed DDS networks;

[0064] Model data storage for implementing persistent storage of SysML model files.

[0065] In the present embodiment, the C# language script functions and modules include:

[0066] General mathematical functions, such as trigonometric functions, exponential, logarithm, power, etc.

[0067] Statistical and random number generation functions, such as min, max, sum, nextNormal, nextUniform, etc.

[0068] Input / output and log functions, such as print, input_int, etc.

[0069] Simulation time and signal management functions, such as GetTime, GetLastSignal, SendSignal, GetValue, SetValue, etc.

[0070] External assembly dynamic loading and method calling functions, such as LoadAssembly, CallMethod, ConvertToJson, BlockToJson, JsonToBlock, etc.

[0071] Data distribution service communication functions, such as DDS.Pub, DDS.Sub, DDS.WaitMsg, etc.

[0072] Simulation interface functions and external data source interaction functions, such as ExcelHelper.GetCellValue, etc.

[0073] It is particularly pointed out that the SysML model data interaction encapsulation library provides a set of high-level, abstract and easy-to-use functions and classes oriented to SysML concepts, thereby realizing reading and writing of SysML model data for simulation preparation and result backwriting. The SysML modeling tool interface is an adapter layer for communication with a target SysML modeling tool (such as Enterprise Architect, Cameo Systems Modeler, etc.). The external simulation and communication interface is an adapter layer.

[0074] Based on the scheme of the embodiment, a C# language-based lightweight simulation automation script engine can be implemented, highly automated and flexible control of complex simulation logic is realized in the SysML environment by dynamically compiling and executing C# scripts, the powerful capabilities of traditional programming languages are seamlessly introduced into model-driven simulation, and the efficiency and customization capabilities are significantly improved. The embodiment allows the simulation engine to directly identify and call scripts embedded in SysML model elements (such as activity diagram actions and state machine transitions), thereby enabling precise and dynamic control and execution of model behavior. Therefore, the embodiment ensures the close coupling of simulation logic and SysML models, enabling models to directly drive complex calculations and interactions. The embodiment also encapsulates underlying data communication (such as DDS and UDP protocols) and provides a high-level and easy-to-use C# API interface, enabling SysML scripts to conveniently perform real-time bidirectional data interaction with external simulation tools or hardware systems, greatly simplifying the difficulty of integrating complex external environments. The embodiment also implements an automated real-time integration scheme for SysML and external simulation environments. Combined with the script engine and high-level API encapsulation, the scheme provides a complete automation framework, enabling real-time and seamless integration of SysML models and external simulation environments (such as distributed simulation and HIL platforms). That is, through scripting, integration efficiency and reliability are greatly improved.

[0075] Embodiment 2

[0076] The embodiment provides a SysML model-driven automated simulation script processing method, which is implemented based on the SysML model-driven automated simulation script processing system of embodiment 1, and refers to Figure 1 , comprising the following steps:

[0077] Step S1: Obtain a simulation script, which is a simulation logic code bound to a SysML model element written in a programming language. When obtaining the simulation script, the script source code can be extracted from the model element (for example, actions in activity diagrams and states and transitions in state machine diagrams), and necessary processing can be performed.

[0078] It is particularly pointed out that the writing method of the simulation script involved in the embodiment is:

[0079] Based on the model-driven development concept, C# and other languages are used to write simulation logic code bound to SysML model elements, and a feature tag is used to realize bidirectional mapping of the simulation script and the SysML model, to ensure that the function parameters and variable definitions are consistent with the SysML model structure, and to form a source code file that can be driven for simulation. SysML model elements include classes, parameters, and signals. The feature tag can use, for example, `[ModelParameter]`.

[0080] After the simulation script is written, the simulation execution can be triggered through a GUI button, an API call, or a DDS event subscription. The simulation script is loaded, the running environment is initialized, a communication connection (e.g., a DDS channel) with an external platform is established, and a timestamp and an execution strategy are set according to the simulation type (real-time / non-real-time).

[0081] Step S2: The simulation script is subjected to lexical analysis to obtain a Token sequence. Through lexical analysis, the original C# code text can be decomposed into a series of tokens with independent meanings. These tokens are the cornerstone of building higher-level syntax structures.

[0082] In this embodiment, the method for performing lexical analysis on the simulation script is as follows:

[0083] Instead of simply using a general regular expression or a traditional state machine to process the entire string, the CSharpSyntaxTree lexical analyzer Lexer is used to scan the simulation script character by character. According to the predefined syntax rules and lexical specifications of the C# language, the continuous character stream is divided into multiple Tokens. Each Token represents a syntax unit in the script, which can include:

[0084] Keywords (such as if, else, while);

[0085] Identifiers (such as variable names myVariable, sensorValue);

[0086] Operators (such as +, -, =, >);

[0087] Literals (such as 123, "hello", true);

[0088] Separators (such as (, ), ;, {,});

[0089] The information of each Token is recorded, including the type, value, and location information in the simulation script. The type indicates what it is, the value indicates its specific content, and the location information can be expressed in terms of line number and column number.

[0090] The Token sequence formed by multiple Tokens and corresponding information provides a structured and standardized basic syntax unit for subsequent semantic analysis, ensuring the accuracy and efficiency of subsequent processing.

[0091] Step S3: The Token sequence is subjected to semantic conversion to map the semantic information to corresponding functions.

[0092] After the lexical analysis, the semantic conversion phase begins to play a role. The core task of this phase is to understand the actual meaning beyond the syntactic structure of the code and map these meanings to predefined functions or operations, in preparation for the final generation or execution of C# code.

[0093] As a preferred solution, the method for semantic conversion of Token sequences is:

[0094] Semantic conversion is usually performed on a complete Syntax Tree, as it provides richer contextual and structural information than a flat Token sequence. By traversing the nodes of the Syntax Tree, various key semantic elements are identified and extracted, including custom function calls (such as print() in scripts), specific variables and constants, and special operators and language constructs;

[0095] At least one Dictionary<TKey, TValue> is defined, which is used to store the mapping relationship between key semantic elements and code snippets or functions in the simulated script, for example:

[0096] Mapping the function name in the simulated script to Console.WriteLine in C#;

[0097] Mapping specific keywords in the simulated script to Boolean true or false in C#.

[0098] Step S4: Extract and parse parameters.

[0099] Parsing parameters mainly involves extracting various attributes based on the simulated script and associating attributes with variables or parameters;

[0100] Perform format and dependency checks to ensure that the data meets the requirements of the simulation logic. Format checks include numerical range, type conversion checks, and dependency checks include parameter combination validity checks.

[0101] Step S5: Integrate the results of semantic conversion and parsed parameters to generate a compilable source code text. This step can achieve the direct translation of processed Token sequences into executable C# code. This process can be achieved through built-in code templates to ensure efficient and consistent generation of the required code, i.e., outputting C# source code text that can be directly compiled.

[0102] Step S6: Perform dependency resolution and compilation based on the source code text to obtain an executable assembly.

[0103] The purpose of dependency resolution is to enable the code to correctly access and utilize the functionality of external libraries. The method for performing dependency resolution based on the source code text in this embodiment is as follows:

[0104] Scanning the source code text to identify program set DLLs;

[0105] Dynamically loading all program set DLLs and adding corresponding using references in the source code text.

[0106] On the other hand, the method for performing compilation based on the source code text is as follows:

[0107] Converting the source code text into intermediate language instructions in real time;

[0108] Generating program sets for direct execution based on the intermediate language instructions to form the executable program set.

[0109] Compilation is mainly to dynamically compile the previously generated source code text into an executable form using a compiler such as Roslyn. The above solution mainly involves Just-In-Time (JIT) compilation. During the compilation process, the system also performs necessary optimizations such as dead code elimination and type safety checks to ensure the efficiency and reliability of the generated code.

[0110] Step S7: Generating a simulation instance based on the executable program set.

[0111] After obtaining the executable program set, the method for generating a simulation instance is as follows:

[0112] Loading the executable program set into memory using the reflection mechanism of.NET;

[0113] Using the Assembly.CreateInstance method to dynamically create a simulation instance from the loaded executable program set.

[0114] The object instantiated through the above method becomes the core of the entire simulation process, carrying the logic converted from the SysML model and script, and fully prepares for subsequent simulation execution.

[0115] A case based on the solution of this embodiment can be referred to Figure 2, the script in the figure represents the simulation script print(“Hello World!!!”) extracted in this embodiment, and the Token sequence obtained after lexical analysis is also shown in the figure as Tokens. Here, the first row from left to right represents four parameters, namely, interface component, interface component.type, interface component.text, and interface component.constant. The second row represents that the interface component is Variable print, the interface component.type is Variable, the interface component.text is print in the simulation script, and the interface component.constant is FALSE, which means that the attribute is not constant (if TRUE, it means that it is constant). In this way, each row of the table represents each symbol in the simulation script. Semicolon represents a semicolon, BracketOpen and BracketClose represent left and right brackets, respectively, and interface component.type is Value, which means that the interface component.type is a value. After semantic conversion, the interface function is obtained, and after a series of operations such as parameter analysis, the source code text is generated, which is represented by source code in the figure.

[0116] During the actual simulation process, the user refers to Figure 3 , and the main process is as follows:

[0117] Start simulation: As the starting point of the entire simulation process, the core of this stage is to comprehensively initialize the simulation environment. The system will load the necessary simulation configuration files, which define in detail the various parameter settings, model paths, and other initial conditions required for simulation. Through accurate configuration, it is ensured that the simulation can be started in a pre-set and controlled environment.

[0118] Engine recognition: During the simulation process, the core is the driving of the SysML model engine. The engine continuously parses and executes the logic in the model, such as the action flow defined in the activity diagram, the state transition logic in the state machine diagram, and the constraint relationship defined in the parameter diagram. When the engine detects specific behaviors or calculations that need to be implemented through external scripts on the model execution path, it will identify the corresponding script requirements.

[0119] Call instance: Once the SysML model engine identifies the instruction that needs to execute the script, it will immediately call the C# code instance generated through compilation. This instance is the specific embodiment of the script logic in the runtime environment, and it carries the precise instructions and calculations transformed from SysML scripts and models. Through this seamless call, it is ensured that the simulation can dynamically integrate and execute complex external business logic, thereby driving the precise advancement of the entire simulation process.

[0120] Call function: This phase is the core of simulation execution, where the system invokes the corresponding function from the instance created earlier. It ensures that all the correct parameters are passed to the function, allowing the simulation to execute the predefined logic directly without worrying about synchronous or asynchronous invocation patterns, complex parameter wrapping, or aspect functionality. The focus is solely on implementing the core computational tasks.

[0121] Return result: This phase is responsible for collecting the data generated by the simulation computation and returning it to the corresponding attribute according to the predefined rules. The system extracts the raw data from the function return value or instance attribute. In this way, the final results of the simulation computation can be accurately and effectively collected and mapped to the corresponding parameters or attributes in the SysML model.

[0122] Feedback user: This is the final stage of the entire simulation process, aiming to present the simulation results in an intuitive and interactive manner, making it easy for users to observe and analyze in depth.

[0123] It is particularly noted that in the system panel, a simulation variable area is preferably specially provided. This area not only allows users to view the current values of key variables and parameters in the simulation process in real time, but also provides the function of modifying these parameters. At the same time, this area is one of the important ways to directly display the results of simulation calculation, allowing users to immediately grasp the latest state and data output of the simulation run. In order to intuitively display the dynamic changes and key data trends in the simulation process, the system supports real-time curve drawing. For example, performance curves, state change graphs, etc. can be updated in real time, allowing users to clearly understand the trends and results of the simulation run.

[0124] The above is only the preferred embodiment of the present application and is not used to limit the present application. For those skilled in the art, the present application can have various modifications and changes. Any modification, equivalent replacement, improvement, etc. made within the spirit and principles of the present application shall be included in the protection scope of the present application.

Claims

1. A SysML model-driven automated simulation script processing method, characterized in that, The SysML model-driven automated simulation script processing system comprises: a user interaction interface / script editor, which provides an environment for a user to write, edit, debug and execute a custom C# language-based simulation script; a script parsing and execution engine, which parses the simulation script and converts it into executable instructions; a SysML model data interaction encapsulation library, which encapsulates underlying APIs of a SysML modeling tool based on the C# language and is used for reading and writing SysML model data; a core operation and custom function library, which is used for predefining C# language script functions and modules; a SysML modeling tool interface, which is used for accessing and modifying SysML model data; an external simulation and communication interface, which is used for data exchange and control with external simulation tools, real-time systems or distributed DDS networks; model data storage, which is used for realizing persistent storage of SysML model files. The SysML model-driven automated simulation script processing method comprises the following steps: obtaining a simulation script, wherein the simulation script is a simulation logic code of SysML model element binding written in a programming language; performing lexical analysis on the simulation script to obtain a Token sequence; performing semantic conversion on the Token sequence to realize mapping of semantic information to corresponding functions; extracting and analyzing parameters; integrating the results of semantic conversion and the analyzed parameters to generate a compilable source code text; performing parsing dependency and compilation based on the source code text to obtain an executable program set; and generating a simulation instance based on the executable program set.

2. The method of claim 1, wherein, The C# language script functions and modules comprise general mathematical functions, statistical and random number generation functions, input / output and log functions, simulation time and signal management functions, external program set dynamic loading and method calling functions, data distribution service communication functions, simulation interface functions and external data source interaction functions.

3. The method of claim 1, wherein, The method for writing the simulation script comprises the following steps: writing a simulation logic code of SysML model element binding by using the C# language, and realizing bidirectional mapping of the simulation script and the SysML model through characteristic markers.

4. The method of claim 1, wherein, The method for performing lexical analysis on the simulation script comprises the following steps: performing character-by-character scanning on the simulation script by using a lexical analyzer Lexer of a CSharpSyntaxTree, dividing a continuous character stream into a plurality of Tokens, and each Token representing a syntax unit in the script; recording information of each Token, wherein the information comprises a type, a value and position information in the simulation script; the plurality of Tokens and the corresponding information form the Token sequence.

5. The method of claim 1, wherein, The method for performing semantic conversion on the Token sequence comprises the following steps: traversing nodes of a syntax tree, identifying and extracting a plurality of key semantic elements, including custom function calling, variables and constants and special operators and language constructs; defining at least one dictionary, which is used for storing mapping relationships between the key semantic elements and code segments or functions in the simulation script.

6. The method of claim 1, wherein, The method for extracting and analyzing parameters comprises the following steps: extracting a plurality of attributes based on the simulation script, and associating the attributes with variables or parameters; performing format checking and dependency checking to ensure that the data meet the requirements of the simulation logic.

7. The method of claim 1, wherein the SysML model-driven automated simulation script processing method further comprises: The method for performing the parsing dependency based on the source code text is: scanning the source code text to identify program set DLLs; loading all program set DLLs dynamically and adding corresponding using reference in the source code text.

8. The method of claim 7, wherein, The method for performing the compiling based on the source code text is: transforming the source code text into intermediate language instruction in real time; generating program set for direct running based on the intermediate language instruction to form the executable program set.

9. The method of claim 1, wherein, The method for generating simulation instance based on the executable program set is: loading the executable program set into memory by using the reflection mechanism of.NET; creating simulation instance from the loaded executable program set dynamically by using the Assembly.CreateInstance method.

Images