Event action modeling and simulation method for engineering system timing behavior analysis

Abstract

The application discloses an event action modeling and simulation method for engineering system timing behavior analysis, comprising the following steps: constructing an event action model based on hierarchical components, defining behavior contracts and timing contracts based on signal timing logic for the components, and deducing composite external contracts through combination algebra to block state space expansion; mapping the model to a weighted time automaton, using a model detection engine to exhaust timing boundaries, and generating an engineering diagnosis script for one-key playback when a violation is found; cutting and deploying the model to distributed logic processes, using a predictive optimistic synchronization mechanism with an embedded long short-term memory network behavior predictor to perform asynchronous simulation, reducing rollback rate, and realizing lock-free garbage collection combined with global virtual time. The application takes into account the safety of formal verification and the high throughput of system-level dynamic simulation, and improves the troubleshooting efficiency of complex engineering system timing defects.

Description

Technical Field

[0001] This invention relates to the field of computer simulation technology, and in particular to an event action modeling and simulation method for timing behavior analysis of engineering systems. Background Technology

[0002] With the development of complex engineering systems such as aerospace and industrial automation, concurrent tasks within systems and interactions across subsystems are becoming increasingly frequent, making the accuracy and reliability of temporal behavior a core indicator of system safety. Currently, the industry mainly uses event-action modeling, system-level simulation, and formal verification techniques to analyze the temporal behavior of engineering systems. However, existing technologies still struggle to balance the rigor of temporal logic verification with the efficiency of large-scale system simulation.

[0003] CN118605848A discloses a method and device for constructing a simulation system based on a neutral simulation language. This solution mainly solves the problems of difficult cross-platform adaptation of simulation models and low efficiency of manual development by extending the simulation concept model, automatically mapping the neutral simulation language, and generating multi-template code. However, this solution does not design a dedicated formal verification mechanism for the temporal behavior of engineering systems, making it impossible to identify implicit defects such as temporal conflicts in the early stages of design. Furthermore, it does not construct a standardized behavior and temporal contract system, nor does it adapt to the distributed simulation optimization needs of ultra-large-scale engineering systems, making it difficult to meet the requirements of full-process temporal behavior analysis for highly reliable engineering systems.

[0004] CN119378039A discloses a behavior event simulation modeling method and system based on entities. This solution solves the problems of data coupling and the difficulty of modeling multi-granularity spatiotemporal objects in combat scenario simulations by decomposing combat scenario objects into concrete entities and event entities for modeling and association. However, this solution is mainly designed around combat scenario simulations and does not adapt to the hierarchical component characteristics and hard real-time timing constraints of industrial engineering systems. At the same time, it lacks a complete formal verification mechanism and a distributed simulation synchronous optimization scheme, which cannot support the rigorous verification of the timing logic of complex engineering systems and the efficient advancement of large-scale global simulation.

[0005] In summary, existing technologies generally suffer from the problems of separation between formal verification and dynamic simulation, and low efficiency of large-scale distributed simulation synchronization mechanisms. They are unable to efficiently and accurately complete the full-process analysis and defect investigation of the temporal behavior of complex engineering systems, and cannot meet the industry's growing demand for high-reliability and high-efficiency simulation analysis. Summary of the Invention

[0006] The purpose of this section is to outline some aspects of embodiments of the present invention and to briefly describe some preferred embodiments. Simplifications or omissions may be made in this section, as well as in the abstract and title of this application, to avoid obscuring the purpose of these documents; however, such simplifications or omissions should not be construed as limiting the scope of the invention.

[0007] In view of the aforementioned existing problems, this invention is proposed. Therefore, this invention provides an event-action modeling and simulation method for temporal behavior analysis of engineering systems, to solve the problems mentioned in the background art.

[0008] To address the aforementioned technical problems, this invention provides the following technical solution: an event action modeling and simulation method for time-series behavior analysis of engineering systems, comprising: Construct an event action model based on hierarchical components, wherein the components include a behavior contract for defining their interaction behavior and a timing contract for constraining their temporal attributes; The event action model or a subset thereof is automatically mapped to a formal model, and the formal model is tested based on a preset attribute specification to verify the correctness of the temporal behavior. The event action model is partitioned and deployed to multiple logical processes. A predictive optimistic synchronization mechanism is used to perform distributed asynchronous simulation to obtain the simulation results of the system's temporal behavior.

[0009] Compared with the prior art, the beneficial effects of the present invention are as follows: 1. This invention performs static consistency checks during the component assembly stage using combinatorial algebra rules, eliminating the need for time-consuming dynamic simulations and thus preventing timing conflicts in the early stages of modeling.

[0010] 2. This invention maps the event action model to a strict weighted time automaton for exhaustive model detection. At the same time, it introduces an inverse mapping mechanism, which can convert obscure mathematical counterexample trajectories into deterministic event sequence scripts containing absolute physical timestamps, thereby enabling one-click fault playback and diagnosis for R&D engineers.

[0011] 3. Furthermore, this invention incorporates a hybrid artificial intelligence architecture into the traditional optimistic synchronization mechanism. By using deep learning to fit the action sequence habits and temporal delay rhythms of physical components, it enables the logical process to make intelligent predictions with a high hit rate rather than blind speculation, reducing the avalanche rollback rate caused by external event inversion, and realizing the efficient advancement of large-scale engineering system simulation and lock-free garbage collection of memory. Attached Figure Description

[0012] To more clearly illustrate the technical solutions of the embodiments of the present invention, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort. Wherein: Figure 1 This is a flowchart illustrating the overall process of an event action modeling and simulation method for timing behavior analysis of engineering systems, as described in one embodiment of the present invention. Detailed Implementation

[0013] To make the above-mentioned objects, features, and advantages of the present invention more apparent and understandable, specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of the present invention, and not all of them. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the protection scope of the present invention.

[0014] Many specific details are set forth in the following description in order to provide a full understanding of the invention. However, the invention may also be practiced in other ways different from those described herein, and those skilled in the art can make similar extensions without departing from the spirit of the invention. Therefore, the invention is not limited to the specific embodiments disclosed below.

[0015] Secondly, the term "one embodiment" or "embodiment" as used herein refers to a specific feature, structure, or characteristic that may be included in at least one implementation of the present invention. The phrase "in one embodiment" appearing in different places in this specification does not necessarily refer to the same embodiment, nor is it a single or selective embodiment that is mutually exclusive with other embodiments.

[0016] Furthermore, in the description of this invention, it should be noted that the terms "upper," "lower," "inner," and "outer," etc., indicate the orientation or positional relationship based on the orientation or positional relationship shown in the accompanying drawings. These terms are used solely for the convenience of describing the invention and for simplifying the description, and do not indicate or imply that the device or element referred to must have a specific orientation, or be constructed and operated in a specific orientation. Therefore, they should not be construed as limitations on the invention. In addition, the terms "first," "second," or "third" are used for descriptive purposes only and should not be construed as indicating or implying relative importance.

[0017] Example 1

[0018] Reference Figure 1 This is the first embodiment of the present invention, which provides an event action modeling and simulation method for timing behavior analysis of engineering systems, including: S1. Construct an event action model based on hierarchical components. The components include behavioral contracts for defining their interactive behaviors and temporal contracts for constraining their temporal attributes.

[0019] It should be noted that in complex engineering systems (such as aerospace and automated production lines), the system is often composed of a massive number of heterogeneous subsystems coupled together. Traditional flattened modeling methods are prone to falling into the computational bottleneck of state space explosion when faced with massive state transitions. To solve this technical problem, this embodiment adopts a bottom-up hierarchical modeling paradigm, abstracting engineering entities in the physical world into software components with mathematical definitions, and realizing the design concept of "correct construction" through contract theory.

[0020] Furthermore, in order to construct the event action model, this invention defines the internal logical architecture and interaction interface of the basic (atomic) level components.

[0021] Specifically, for the most basic execution unit or sensor unit in an engineering system, which is a component, a formalized tuple is defined for that component. Among them, input and output ports It is used to receive external stimulus events or send response events. Input ports are the collection of entry points used by a component to listen for or receive external environmental commands, sensor signals, or events triggered by front-end nodes. Output ports are the set of outlets through which a component sends result signals, alarm information, or trigger commands to the external environment or other related components after performing an action. Internal state variables V represent the set of physical or logical state spaces currently occupied by the component (e.g., valve opening degree, temperature sensor value). Event-Condition-Action (ECA) rules: defining the rule set as... Each rule All are expressed using a triplet structure as Its significance lies in: when a specific event is detected. When it occurs, and the current internal state variable satisfies the triggering condition. At that time, the component performs an action. (This action includes updating internal state variables or issuing new events through output ports.)

[0022] It should be noted that by constructing this rule, the control flow and data flow of the system can be precisely decoupled.

[0023] Furthermore, a dual contract for behavior and timing is constructed based on an assumption-guarantee framework.

[0024] Specifically, in order to regulate the externally visible characteristics of a component without exposing its internal ECA rules, the present invention introduces a contract model for each component, denoted as... .in, This represents the component's assumptions about the external operating environment. Indicates that when the condition is met Under the premise that the component promises to provide output.

[0025] It should be emphasized that, in this invention, the core driving mechanism of the event action model is the ECA rules distributed within each component.

[0026] Furthermore, the contract model is decoupled as follows: Behavioral contract: Used to regulate the sequence of discrete event interactions that are allowed to occur on input and output ports. It is usually represented by regular expressions or finite state automata and is used to filter out illegal temporal topology deadlocks.

[0027] Timing Contract: Considering the large number of continuous physical quantities and strict time boundaries in the engineering system, this embodiment uses Signal Sequential Logic (STL) to define quantization time constraints. It should be explained that by utilizing the characteristics of STL, it can handle not only Boolean logic but also logic with continuous time intervals. The timing constraint formulas defined in this process are as follows: in, This is represented as a defined timing constraint rule. For global operators, it means within the global time window. Within the brackets, the logical implication must always be true. For input events, State variables (It can be internal or external) satisfy a certain numerical threshold. ( Both constitute the triggering condition. For the final operator, it represents the relative time window after the condition is triggered. Inside. This is the necessary output action. It is represented as a logical AND. This indicates a trigger operation.

[0028] It should be explained that the above timing constraint rule requires that at any time during the entire task execution time window, if an input command is received and the current state parameter of the device reaches a certain value threshold, then the output action triggered by this must be completed within the relative time window.

[0029] Furthermore, hierarchical composite components are assembled based on port mapping rules.

[0030] Specifically, multiple predefined low-level components are acquired (in this embodiment, components are used as the basis for identification). and For example, by defining a port connection mapping function By connecting the output port of the pre-component to the input port of the post-component, the lower-level components are encapsulated and hidden, forming a black-box-like high-level composite component, denoted as... ( (For combined operators).

[0031] It should be emphasized that this assembly operation supports infinite recursive nesting, thereby mapping extremely complex engineering equipment hierarchical structures.

[0032] Furthermore, the derivation and verification of contract consistency based on combinatorial algebra algorithms are presented.

[0033] Specifically, traditional simulation methods require the entire system to be built before timing conflicts can be detected, resulting in extremely high rework costs. Therefore, this invention, while assembling composite components, utilizes contract combinatorial algebra rules to perform real-time static consistency checks and external contract derivation. Specifically, let the components... The contract is ,member The contract is and components The output is connected to the component. The input is... The verification of the combinatorial algebra rules executes the following logic: First, perform a consistency check and calculate the Boolean intersection. .like This is not true; that is, the output timing properties promised by the preceding component exceed the input assumptions that the subsequent component can tolerate (e.g., component...). It promises to output a signal within 50ms, but the component... If the contract assumes that its input signal must arrive within 30ms, the system will throw a timing conflict warning during the modeling phase and reject the assembly operation. If the consistency check passes, the higher-level composite component is automatically derived. New external contract Its derivation formula is: Among them, the assumption of composite components It is the conjunction of all its internal sub-components, but it is necessary to subtract or remove those that have been assumed to be internal sub-components (i.e., and The guarantee of a component satisfies the assumptions (i.e., internally digested dependencies); while the guarantee of a composite component... It is the combination of all sub-components' external output guarantees.

[0034] It should be noted that, through the aforementioned combinatorial algebra rules, the system does not need to actually execute time-consuming dynamic simulation flows; it can complete early temporal pruning of large-scale topologies using only the above derivation calculations. Simultaneously, the generated new external contracts can be directly used as black-box contracts for the next level of assembly, thereby preventing the expansion of the state space and improving the computational feasibility of modeling large-scale engineering systems.

[0035] S2. Automatically map the event action model or its subset to a formal model, and perform model checking on the formal model based on the preset attribute specification to verify the correctness of the temporal behavior.

[0036] Furthermore, although the present invention completes the static consistency check during component assembly through combinatorial algebra rules in S1, this only guarantees the legality of the topological connection. However, in the actual operation of the engineering system, the state interaction and time progression between different concurrent components will generate a huge dynamic interleaving space. In order to ensure the safety of critical timing logic (such as escape tower ignition timing and valve interlock control) before the system is put into production, this embodiment adopts model checking technology, that is, to traverse all possible timing boundaries through mathematical exhaustion.

[0037] Furthermore, the engineering semantics of the event-action model are converted into the mathematical semantics of a weighted time automaton.

[0038] Specifically, since ordinary event-action models focus on engineering representation and lack an axiomatic system that can be directly deduced by computers, this invention uses a pre-defined semantic transformation compiler to automatically map the components in S1 into a weighted time automaton with data variables, defining this automaton as a seven-tuple model. This seven-tuple model can be represented as: ,in It is a discrete set of locations, directly mapped from the internal state variables of the components in S1, representing the specific physical mode (e.g., standby, running, fault) of the component at a certain moment. This is the initial safe position of the component. It is a set of continuous real clocks used to measure the absolute or relative passage of time in system operation. For a set of data variables, the continuous physical quantities involved in the mapping component (e.g., discretized values ​​of temperature and pressure). Let be the set of state transition edges, where Represented as the Cartesian product operator; This refers to the initial state of the equipment before the action occurs (e.g., the valve is closed, or the system is in standby mode). These represent the objective conditions that must be met for a state to transition. It is Boolean logic, that is, an expression that judges whether something is true or false; Represented as the Cartesian product operator, it is used to combine elements from different sets; This indicates the instructions or events that occur when the conditions are met, i.e., actions (such as sending an alarm signal or starting a water pump). Represented as a power set of clock sets, i.e., containing The set of all subsets is equivalent to determining which timers (clocks) need to be reset at the moment of state transition (e.g., if there are 3 timers in the system, when this action occurs, it may only be necessary to reset the 1st and 2nd timers to restart). (a combination within) After the action is completed, the device enters a new state (e.g., from standby state to running state). As a position invariant, it aims to map the timing contract in S1 to the clock constraint of the current position, thereby forcing the system to leave the current position before the clock reaches its upper limit, and is used to simulate the hard real-time timeout forced triggering mechanism in physical engineering. This is a weighting function used to quantify the energy consumption or communication overhead during state transitions.

[0039] Specifically, based on the set of state transition edges in the aforementioned seven-tuple model, these edges are mapped onto the ECA rules in S1, becoming the edges of the automaton. , and For the source and target locations; For guard conditions, used to map trigger conditions in ECA, if and only if An edge can only be activated if the following conditions are met; For update operations, clock variables in the clock set are reset at the moment of state transition, or sets of updated data variables are used for updates. Data variables in the data.

[0040] For example, suppose we need to describe a rule for a boiler cooling system. The rule would be mapped as follows: when the boiler is in heating mode, if the temperature variable is greater than 100 degrees and lasts for more than 10 minutes, a shutdown command is immediately sent and the cooling countdown timer is reset to zero, and the system enters cooling mode.

[0041] Furthermore, attribute reduction and model detection deduction are constructed based on timed computation tree logic.

[0042] Specifically, after completing the model mapping, the engineering safety requirements (e.g., the power must be cut off within 5ms after an alarm occurs under any circumstances) need to be converted into computer-verifiable attribute specifications. Based on this, this embodiment employs a timed computation tree logic expression. To describe the above specifications, let's take defining a security specification as an example: in, The path quantifier (representing all possible execution paths) aims to require the detection algorithm to prove that at any time along any trajectory of the entire system, as long as the system enters the Alarm state, the timer clock... The value must be less than or equal to 5.

[0043] Subsequently, the model's detection engine employs a state-space search algorithm based on the difference constraint matrix. Since continuous time is infinite, this algorithm introduces the concept of clock equivalence classes to divide the infinite number of time points into finite clock domains, thus preventing the computer from getting stuck in an infinite loop when extrapolating the passage of time. It's important to note that during this process, the detection engine first performs a breadth-first search on these finite clock domain graphs to verify whether the logical expression holds true at all nodes.

[0044] Furthermore, reverse semantic mapping and diagnostic information generation are based on the trajectories of counterexamples of illegal paths.

[0045] Specifically, when the model's detection engine detects that a certain exploration path does not satisfy the logical expression (i.e., the system may experience timeouts or deadlocks under extreme concurrent timing conditions), the engine will stop searching and generate a counterexample trajectory. Mathematically, this trajectory is represented as a sequence containing position and clock assignments: in, Representing the The specific value of the clock step; This represents the time delay in staying at this location; Indicates the initial position; This represents the initial value of the clock. Indicates an error location; This indicates an incorrect clock value.

[0046] It should be explained that the above trajectory is intended to express which actions the system underwent, how long each action was delayed, and finally, at which specific location and time on which device the violation occurred.

[0047] Furthermore, since the aforementioned purely mathematical counterexample trajectories are difficult for engineering technicians to understand directly, this embodiment also introduces a reverse mapping mechanism, specifically as follows: First, create a reverse lookup table to store the positions in the counterexamples. This is restored to the specific physical state of each component in the event-action model; then, the action is... and time delay The sequence is restored to a deterministic event sequence containing explicit timestamps (e.g., the valve sends a closing command at 10.2 ms); finally, a diagnostic script for simulation reproduction is generated based on the transformed deterministic event sequence.

[0048] It should be noted that through this reverse mapping mechanism, R&D personnel do not need to have a deep theoretical computer science background to directly import the generated diagnostic scripts into the system simulator for one-click fault playback, thereby reproducing the rare critical conditions that cause the timing logic to collapse, and thus shortening the fault diagnosis cycle of complex engineering systems.

[0049] S3. Partition the event action model and deploy it to multiple logical processes. Use a predictive optimistic synchronization mechanism to perform distributed asynchronous simulation and obtain the simulation results of the system's temporal behavior.

[0050] It should be noted that, while ensuring timing safety, when dealing with the entire engineering system (e.g., a fully automated factory), the computational bottleneck of state space explosion is inevitable. Therefore, the model of this invention is mainly used for static verification of local key subsystems. To dynamically evaluate the timing flow of the global system, this embodiment introduces a distributed asynchronous simulation framework based on the successful S2 verification.

[0051] Furthermore, load balancing and communication dimensionality reduction partitioning are performed on the event action model based on graph partitioning algorithms.

[0052] Specifically, due to the massive number of components in the engineering system, running it on a single computing node would lead to severe congestion. Therefore, this embodiment represents the constructed event-action model as a directed weighted communication graph. ,in, This represents the set of nodes in the diagram (i.e., the individual components). This represents the set of edges in the graph (i.e., the port connection topology between components). The node weight function represents the average computational load (e.g., the number of CPU clock cycles consumed) required for a single component to process one internal state transition. The edge weight function represents the communication overhead (e.g., network transmission delay and message size) required to transmit an event message between components.

[0053] Furthermore, in order to deploy this directed weighted communication graph to In a distributed logical process, the system uses spectral clustering or a multi-level graph partitioning algorithm (such as the METIS algorithm) to segment the directed weighted communication graph. The optimization objective function for the segmentation is defined as: The objective function aims to find an optimal cutting surface. Constraints It requires allocation to each logical process. Total computational load The target value must be as close as possible to the average of the total system load to avoid idle computing power or individual nodes becoming the weakest link due to overload. At the same time, the goal of optimizing this objective function is to minimize the sum of edge weights that cross different partition boundaries (i.e., cross-process cross-network communication overhead).

[0054] It should be noted that, through this process, the present invention can reduce the frequency of the most time-consuming network communication interaction between distributed nodes from the perspective of physical topology during the simulation initialization stage, thereby laying a structural foundation for the advancement of high concurrency.

[0055] Furthermore, we build and train an AI behavior predictor for predictive execution.

[0056] Specifically, the traditional Time Warp optimistic synchronization mechanism, when handling asynchronous concurrent events, blindly extrapolates to future time points if the local queue is temporarily empty. Once a real external event with a historical timestamp is received, it triggers a large-scale avalanche-like rollback, wasting significant computing power. Therefore, this embodiment embeds an AI-based behavior predictor within each logical process, aiming to transform blind speculative behavior into intelligently predictive behavior. Specifically, this behavior predictor is a hybrid architecture machine learning model, consisting of two modules, with the following network structure and data flow rules: The first module is the discrete state probability transition module. It adopts a Markov chain model to statistically construct a state transition probability matrix based on the historical operation logs of the components, and outputs the prior probability of the current state transitioning to the next discrete state.

[0057] The second module is a recurrent neural network (RNN) time and action prediction module. In this embodiment, a long short-term memory network (LSTM) is preferred to process time-series signals with long-range dependencies. Its network layer connections and data mapping mechanism are as follows: Input data settings: The input feature vector of this Long Short-Term Memory network layer is composed of two parts: the first part is the discrete state encoding vector of the component (the project state is obtained through One-Hot encoding, such as [1,0,0] for standby); the second part is the window of the sequence of recently received input events (including recent events). (The type encoding of each event and the relative time interval between their occurrence). It should be noted that for continuous physical quantities in engineering systems (such as temperature, pressure, and other data variables), Min-Max normalization is used to map them to the [0,1] interval before input to eliminate the influence of dimensions on the gradient of the neural network.

[0058] Output data setup: The input feature vector of the Long Short-Term Memory (LSTM) network layer is fed into the hidden layer of the LSM network to obtain the hidden state. Then, this input feature vector is connected to two parallel fully connected layer branches. The first branch (action classification branch) uses the Softmax activation function and outputs the probability distribution of the types of actions that may occur in the future. The second branch (time regression branch) uses the ReLU activation function and outputs the relative time interval of the predicted action.

[0059] Model Training: Legitimate trajectory logs generated during initial single-machine debugging or S2 model detection are extracted as the training set. A loss function is constructed, set as a function of the joint cross-entropy loss (for accuracy in classifying action types) and the mean squared error loss (for accuracy in regressing time intervals). During model training, the batch size is set to 64, the initial learning rate is 0.001, and gradient descent is performed using the Adam optimizer with an early stopping mechanism. Convergence is achieved when the joint loss value no longer decreases for 10 consecutive iterations on the validation set, thus enabling the model to possess the ability to perform deep learning and fit the inherent operating rhythms of complex engineering equipment.

[0060] Furthermore, predictive optimism is simultaneously executed and rolled back based on behavior predictors.

[0061] Specifically, during the distributed asynchronous simulation process, each logical process independently maintains its own local virtual time and event queue. Specifically, when the timestamp of an event pending processing in a logical process's local event queue exceeds a preset safe waiting threshold (i.e., the node is in a data-starved state), the trained hybrid model is invoked. Using the predicted action type and time interval, a speculative event is generated, and its timestamp is labeled as local virtual time + time interval. The logical process then executes this speculative event ahead of schedule and stores a snapshot of its state before and after execution in the historical state log stack. If, in subsequent physical time, the logical process receives a real external event from another partition on the network, and the timestamp of this external event is less than the timestamp of the already executed speculative event (i.e., a time-series reversal occurs), the system determines that the prediction has failed. At this point, the logical process triggers a rollback mechanism: it reverses the historical state log stack to restore the last valid state snapshot before the timestamp of the external event, sends a counter-message to the associated nodes to cancel the cascading events issued due to the erroneous speculation, and then re-executes them in the correct order.

[0062] It should be noted that, due to the accurate fitting of the inherent behavior of physical components by the deep learning model, the prediction accuracy will far exceed that of random probability. This allows the system to maintain extremely high concurrency while reducing most of the rollback rates in the traditional optimistic synchronization mechanism to single digits, thereby improving the efficiency of system-level simulation.

[0063] Furthermore, global virtual time calculation and garbage collection are based on asynchronous hierarchical algorithms.

[0064] Specifically, because this rollback mechanism requires continuous storage of state logs, failure to clean them up will lead to node memory overflow. Therefore, a network-wide secure time threshold, i.e., a global virtual time, must be calculated. Any event with a timestamp less than this global virtual time will be considered a completed conclusion and will never be rolled back.

[0065] Furthermore, based on the aforementioned global virtual time, this embodiment employs an asynchronous hierarchical algorithm for calculation.

[0066] Specifically, all logical processes are organized into a logical control tree. The leaf nodes at the bottom level report their local virtual time and the minimum timestamp of the messages in transit to their parent nodes at fixed physical time intervals. The parent node collects data from its child nodes, takes the minimum value, and reports it to the next layer. Finally, the root node calculates the current global virtual time and asynchronously broadcasts it to all nodes via multicast.

[0067] It should be noted that the main advantage of this calculation method is that it eliminates the need for global synchronization. Traditional algorithms require pausing the entire simulation network when calculating the global virtual time, while this algorithm allows each node to continue its simulation tasks in parallel during the reporting and receiving of the global virtual time. Upon receiving the new global virtual time, each node can safely perform garbage collection: permanently erasing historical state snapshots and processed events with timestamps less than the global virtual time, thus achieving dynamic cyclic reuse of memory.

[0068] Furthermore, iterative optimization of the event-action model is performed.

[0069] Specifically, after obtaining the results of the aforementioned distributed asynchronous simulation, the data (e.g., time-series congestion nodes that frequently experience rollbacks, and occasional timeout vulnerabilities exposed by dynamic simulation) is combined with the underlying diagnostic scripts generated by model detection in S2. This serves as an objective basis for iteratively optimizing the original event action model, guiding R&D engineers to specifically modify the ECA behavior rules within specific components, or to relax / tighten the time constraint window in the STL timing contract, thereby forming an integrated engineering digital twin system encompassing modeling, verification, simulation, and optimization.

[0070] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the technical solutions of the present invention, and all such modifications or substitutions should be covered within the scope of the claims of the present invention.

Claims

1. An event-action modeling and simulation method for time-series behavior analysis of engineering systems, characterized in that, include: Construct an event action model based on hierarchical components, wherein the components include a behavior contract for defining their interaction behavior and a timing contract for constraining their temporal attributes; The event action model or a subset thereof is automatically mapped to a formal model, and the formal model is tested based on a preset attribute specification to verify the correctness of the temporal behavior. The automatic mapping is a formal model, including: The discrete states and data variables of the components are mapped to the positions and variables of a weighted time automaton with data variables, the event-condition-action rules are mapped to the edges of the automaton and their guard and update operations, and the temporal contract is mapped to the clock constraints of the automaton. The formal model detection based on preset attribute specifications includes: When a violation of the attribute specification is detected, a counterexample trajectory representing the violation path is generated; The counterexample trajectory is reverse-mapped and converted into a deterministic event sequence in the event action model; Diagnostic information for simulation reproduction is generated based on the event sequence; The event action model is partitioned and deployed to multiple logical processes. A predictive optimistic synchronization mechanism is used to perform distributed asynchronous simulation to obtain the simulation results of the system's temporal behavior.

2. The event action modeling and simulation method for time-series behavior analysis of engineering systems as described in claim 1, characterized in that, Constructing the event action model includes: Define input / output ports, internal state variables, and a set of event-condition-action rules for each component; The behavioral contract is used to regulate the sequence of event interactions allowed by the rules, and the timing contract defines the quantized time constraints between event occurrence and state change based on signal timing logic.

3. The event action modeling and simulation method for time-series behavior analysis of engineering systems as described in claim 2, characterized in that, Also includes: By connecting the ports of lower-level components, higher-level composite components are assembled. During the assembly process, according to the preset combinatorial algebra rules, the behavioral contracts and temporal contracts of the lower-level components are combined and checked for consistency, and the external contracts of the higher-level composite components are derived and verified.

4. The event action modeling and simulation method for time-series behavior analysis of engineering systems as described in claim 1, characterized in that, The event action model is partitioned, including: The model is represented as a component communication graph, where the node weights in the communication graph represent the computational load of the components, and the edge weights represent the communication overhead between components. The communication graph is divided using a graph partitioning algorithm to minimize the communication overhead between partitions and balance the computational load of each partition.

5. The event action modeling and simulation method for time-series behavior analysis of engineering systems as described in claim 1, characterized in that, The predictive optimistic synchronization mechanism includes: In each logical process, a behavior predictor is trained based on the historical behavior of the components it manages; When the timestamp of an event to be processed in the local event queue exceeds the preset range, the behavior predictor is used to generate speculative events that may occur in the future and execute them in advance. When an external event that contradicts a speculative event is received, a rollback operation is performed to undo the execution of the speculative event.

6. The event action modeling and simulation method for time-series behavior analysis of engineering systems as described in claim 5, characterized in that, The behavior predictor is a hybrid model, which includes: A probabilistic model for predicting discrete state transitions of a component, and a recurrent neural network model for predicting the type and timing of future output actions based on the component's current state and recent input event sequences.

7. The event action modeling and simulation method for time-series behavior analysis of engineering systems as described in claim 1, characterized in that, The execution of distributed asynchronous simulation includes: An asynchronous hierarchical algorithm is used to calculate the global virtual time, in which each logical process can report its local virtual time to its upper-level node without global synchronization, and the root node calculates and broadcasts the global virtual time. Events and status logs that have been processed and whose timestamps are less than the global virtual time are recycled according to the global virtual time.

8. The event action modeling and simulation method for time-series behavior analysis of engineering systems as described in claim 1, characterized in that, The method further includes: The diagnostic information generated by the model detection, or the simulation results obtained by the distributed asynchronous simulation, are used as the basis for iterative optimization of the event action model to correct the behavior rules of the components or adjust their timing contracts.

Images