Cross-level modeling collaborative design method based on digital bus

Abstract

The invention discloses a cross-level modeling collaborative design method based on a digital bus, and relates to the technical field of system engineering.The method comprises the steps that the digital bus and virtual projection nodes are established between a system-level model and a component-level model, and original time sequence data of the component-level model are mapped into semantic feature vectors through feature extraction processing; calculating a sensitivity factor of a target parameter of the system-level model to the semantic feature vector; obtaining a weighted change influence value in combination with the change quantity of the semantic feature vector; superposing the accumulated deviation values to obtain an estimated accumulated deviation value; respectively comparing the weighted change influence value and the estimated accumulated deviation value with a preset collaborative tolerance threshold value; if the two are both smaller than the cooperative tolerance threshold value, silent updating is executed, and a recalculation signal is intercepted; otherwise, forced synchronization is executed, data is pushed to trigger iteration, and deviation is reset. According to the method, silent updating is achieved through feature extraction and sensitivity control, invalid iteration and parameter oscillation are avoided, and balance between simulation efficiency and design precision is achieved.

Description

Technical Field

[0001] This application relates to the field of systems engineering technology, and in particular to a cross-level modeling and collaborative design method based on a digital bus. Background Technology

[0002] With the increasing complexity of high-end equipment systems in aerospace, precision manufacturing, and automotive electronics, model-based systems engineering (MBSE) has become the mainstream R&D paradigm. The development of these complex systems typically follows a V-shaped process, involving multi-level collaborative design of system-level, subsystem-level, and component-level models. Existing collaborative design methods mainly rely on digital bus technologies such as Functional Mock-up Interface (FMI) or Data Distribution Service (DDS) for parameter transfer.

[0003] However, existing technologies have two shortcomings in cross-level collaboration. First, there is convergence oscillation caused by the spatiotemporal semantic gap. Upper-level system-level models are based on discrete events and focus on macroscopic performance indicators such as task completion rate and average power, while lower-level component-level models are typically based on continuous-time differential equations, outputting high-frequency, transient physical quantities such as millisecond-level voltage fluctuations and instantaneous torque. Existing digital buses lack the ability to understand data semantics, directly transmitting high-frequency fluctuations from the lower layer as signals to the upper layer. This causes the upper-level model to overreact to irrelevant transient details, easily leading to repeated oscillations in system-level parameters. This traps collaborative design in a cycle of modification, verification, failure, and further modification, making convergence difficult.

[0004] Second, there is the problem of ineffective synchronization due to a lack of sensitivity assessment. At different stages of collaborative design, the sensitivity of the upper-level system to changes in the parameters of the lower-level system varies significantly. Existing technologies typically employ a full synchronization mechanism that is triggered by any change. Once the lower-level model modifies a non-critical parameter, the joint simulation of the entire system is forcibly triggered. This blind synchronization not only consumes a huge amount of computing bandwidth but also creates a large number of false design conflicts, resulting in a significant amount of time being spent dealing with minor changes that do not affect system performance. Summary of the Invention

[0005] To address the aforementioned shortcomings, this application provides a cross-level modeling and collaborative design method based on a digital bus, which solves the problems of ineffective iteration and convergence difficulties caused by the lack of sensitivity awareness in existing cross-level collaborative design technologies.

[0006] This application provides a cross-level modeling and collaborative design method based on a digital bus, including:

[0007] Establish a digital bus between the system-level model and the component-level model, configure virtual projection nodes and data buffers, and initialize the cumulative deviation value in the data buffers;

[0008] The raw time-series data output by the component-level model is intercepted by the virtual projection node, and feature extraction processing is performed to map the raw time-series data into semantic feature vectors.

[0009] Obtain the target parameters of the system-level model, calculate the dependence of the target parameters on the semantic feature vector, and generate a sensitivity factor; monitor the amount of change in the semantic feature vector, calculate the product of the amount of change and the sensitivity factor, and obtain the weighted change impact value.

[0010] Obtain the current cumulative deviation value in the data cache, calculate the sum of the weighted change impact value and the cumulative deviation value to obtain the estimated cumulative deviation value; compare the weighted change impact value and the estimated cumulative deviation value with the preset collaborative tolerance threshold respectively;

[0011] In response to the fact that both the weighted change impact value and the estimated cumulative deviation value are less than the collaborative tolerance threshold, a silent update operation is performed to update the value of the semantic feature vector in the data cache and intercept the recalculation trigger signal sent to the system-level model.

[0012] In response to the weighted change impact value or the estimated cumulative deviation value being greater than or equal to the collaborative tolerance threshold, a forced synchronization operation is performed, the updated semantic feature vector is pushed to the system-level model, cross-level collaborative iteration is triggered, and the cumulative deviation value is reset.

[0013] Optionally, a virtual projection node and a data buffer are configured in the digital bus, including:

[0014] Read the interface definition file of the component-level model and parse the data type definition and preset clock frequency parameters of the output port;

[0015] Instantiate a data interface object on the digital bus as a virtual projection node; the properties of the data interface object match the data type definition of the output port;

[0016] Set data interception rules for virtual projection nodes, including the trigger conditions and frequency of data sampling.

[0017] Optionally, the feature extraction process includes:

[0018] The original time-series data is sampled by a sliding window using the virtual projection node to obtain discrete data points for multiple consecutive time segments;

[0019] For each discrete data point in a time segment, calculate one or more statistical characteristic indicators, including mean, variance, peak value, and root mean square value.

[0020] The statistical feature indicators are dimensionality-reduced and mapped to generate semantic feature vectors.

[0021] Optionally, the statistical feature indicators are subjected to dimensionality reduction mapping, including:

[0022] Using a linear projection transformation algorithm, the projection values ​​of the statistical feature indicators on the basis vectors are calculated, and the projection components that satisfy the preset variance contribution rate are selected to form a semantic feature vector; or, the statistical feature indicators are input into a pre-trained neural network encoder, and the output values ​​of the hidden layer are extracted as semantic feature vectors.

[0023] Optionally, obtain the target parameters of the system-level model, including:

[0024] Traverse the variable list of the system-level model, filter out the variables marked as key performance indicators, and determine them as the monitoring objects.

[0025] Establish a signal transmission path between the input port of the system-level model and the monitored object variable;

[0026] Read the values ​​of the monitored object variables at the current simulation step size and use them as target parameters.

[0027] Optionally, the dependence of the target parameters on the semantic feature vector is calculated to generate a sensitivity factor, including:

[0028] A test bias value with a preset value is superimposed on each dimension component of the semantic feature vector to generate a test feature vector.

[0029] Input the test feature vector into the system-level model and record the numerical changes in the target parameters.

[0030] The ratio of the numerical change to the test bias is calculated and used as the sensitivity factor for the corresponding dimensional component.

[0031] Optionally, monitoring the changes in the semantic feature vector includes:

[0032] Retrieve the historical semantic feature vector stored in the data cache;

[0033] Calculate the numerical differences in each dimension between the semantic feature vector generated at the current moment and the historical semantic feature vector;

[0034] The scalar magnitude of the numerical difference is calculated using a distance metric function, and the scalar magnitude is used as the change amount of the semantic feature vector.

[0035] Optionally, the preset cooperative tolerance threshold includes:

[0036] Read the simulation configuration table of the system-level model, which includes the accuracy level values ​​corresponding to different simulation stages;

[0037] Identify the simulation stage of the current simulation time step of the system-level model, and extract the value corresponding to the current simulation stage and accuracy level from the configuration table as the cooperative tolerance threshold.

[0038] Optionally, performing the silent update operation includes:

[0039] Update the cumulative deviation value in the data cache, and write the estimated cumulative deviation value into the data cache to overwrite the original cumulative deviation value;

[0040] Write the semantic feature vector generated at the current moment into the data cache area, overwriting the original data;

[0041] Return the semantic feature vector from the previous time step to the system-level model, and maintain the interception state of the system-level model recalculation trigger signal.

[0042] Optionally, the forced synchronization operation includes:

[0043] Send an interrupt signal to the system-level model to pause the current simulation step;

[0044] The latest semantic feature vectors are written into the input interface of the system-level model via a digital bus;

[0045] Reset the cumulative deviation value in the data buffer to zero;

[0046] The interrupt signal is canceled and a recalculation trigger signal is sent. The instruction system-level model recalculates the current or next simulation step based on the written semantic feature vector.

[0047] Compared with existing technologies, this application configures virtual projection nodes to extract features from the raw time-series data of the component-level model and maps it into semantic feature vectors. This mechanism abstracts the low-level high-frequency, transient physical data into high-level low-frequency, steady-state semantic features that are easy to understand. It effectively filters out fluctuation details that have no substantial impact on system-level performance, eliminates repeated oscillations of system-level parameters caused by the spatiotemporal semantic gap, and improves the convergence speed and stability of cross-level collaborative design.

[0048] A sensitivity factor and a weighted change impact value are introduced. By calculating the dependence of target parameters on semantic feature vectors, the underlying parameters that truly influence the performance of the upper-level system are identified. For changes with low sensitivity or minor magnitude, a silent update operation is performed and recalculation trigger signals are intercepted. This avoids frequent system-level recalculations triggered by minor changes in non-critical parameters, reduces the computational cost of co-simulation, and decreases the number of design iterations caused by spurious conflicts.

[0049] A cumulative deviation monitoring mechanism was established, which not only assesses the impact of individual changes but also accumulates historically intercepted silent errors to calculate the estimated cumulative deviation value. When the impact of a single change is minor but the cumulative error exceeds the collaborative tolerance threshold, a forced synchronization operation is immediately executed and the deviation is reset. While pursuing efficient silent updates, the overall simulation accuracy of the system is controlled within a reliable range, achieving an optimal balance between simulation efficiency and design accuracy. Attached Figure Description

[0050] Figure 1 A flowchart illustrating a cross-level modeling and collaborative design method based on a digital bus, provided for embodiments of this application;

[0051] Figure 2 A flowchart of the feature extraction process provided in the embodiments of this application;

[0052] Figure 3 This is a flowchart for generating sensitivity factors provided in an embodiment of this application. Detailed Implementation

[0053] The technical solutions in the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments.

[0054] See Figure 1 This application provides a cross-level modeling and collaborative design method based on a digital bus, comprising steps S101 to S106, wherein:

[0055] S101, establish a digital bus between the system-level model and the component-level model, configure virtual projection nodes and data buffers, and initialize the cumulative deviation value in the data buffers;

[0056] S102, intercept the raw time series data output by the component-level model through the virtual projection node, perform feature extraction processing, and map the raw time series data into semantic feature vectors;

[0057] S103, obtain the target parameters of the system-level model, calculate the dependence of the target parameters on the semantic feature vector, and generate a sensitivity factor; monitor the change amount of the semantic feature vector, calculate the product of the change amount and the sensitivity factor, and obtain the weighted change impact value;

[0058] S104, obtain the current cumulative deviation value in the data cache, calculate the sum of the weighted change impact value and the cumulative deviation value to obtain the estimated cumulative deviation value; compare the weighted change impact value and the estimated cumulative deviation value with the preset collaborative tolerance threshold respectively;

[0059] S105, in response to the fact that both the weighted change impact value and the estimated cumulative deviation value are less than the collaborative tolerance threshold, a silent update operation is performed to update the value of the semantic feature vector in the data cache and intercept the recalculation trigger signal sent to the system-level model;

[0060] S106, in response to the weighted change impact value or the estimated cumulative deviation value being greater than or equal to the collaborative tolerance threshold, a forced synchronization operation is performed to push the updated semantic feature vector to the system-level model, trigger cross-level collaborative iteration, and reset the cumulative deviation value.

[0061] Regarding the above S101:

[0062] In cross-level modeling and collaborative design scenarios, system-level models and component-level models belong to different design levels. When the two interact with each other, there are common technical problems such as interface incompatibility, data transmission delay, asynchronous interaction, and lack of initial benchmark for the accumulation of deviations. These problems can lead to chaotic data transmission, low model iteration efficiency, and even cause the continuous accumulation of collaborative design deviations, making it impossible to accurately control the design accuracy and affecting the collaborative effect and design reliability of cross-level modeling.

[0063] In step S101 of this embodiment, a standardized digital bus is constructed as a data interaction hub between the system-level model and the component-level model. At the same time, virtual projection nodes are configured to achieve precise interception and forwarding of data transmission. A data buffer is used to achieve temporary storage of data and real-time recording of deviation values. The initialization of the cumulative deviation value provides a benchmark reference for subsequent deviation calculation, laying the foundation for data interaction and deviation control in the entire cross-level collaborative design.

[0064] Among them, the digital bus is a communication architecture used to realize standardized data transmission and interaction between system-level models and component-level models. It can be compatible with data formats of different levels of models and realize efficient and real-time data transmission. For example, the digital bus is built using the data distribution service bus protocol, which supports real-time and highly reliable point-to-point and multi-point data transmission and can adapt to the high-concurrency data interaction needs in industrial-grade modeling scenarios.

[0065] A virtual projection node is a functional node deployed between the digital bus and the output of the component-level model. It is used to intercept the data output by the component-level model and perform preliminary processing, while realizing accurate projection transmission of data between the digital bus and the model.

[0066] The data cache is a storage area set up within the digital bus architecture to temporarily store intercepted component-level model data, cumulative deviation values, etc., ensuring data traceability and real-time retrieval. The cumulative deviation value is a parameter used to record the cumulative amount of deviation caused by changes in component model data to the system-level model.

[0067] In practical implementation, the first step is to establish a digital bus. Those skilled in the art can select a suitable bus protocol based on the actual modeling tools and scenarios, prioritizing industrial-grade bus protocols that support real-time data transmission. Taking the commonly used DDS bus protocol as an example, first, install the appropriate DDS bus communication plugin in the modeling platforms corresponding to the system-level and component-level models, such as MATLAB's Simulink and AMESim. Then, configure the bus communication parameters, including setting the communication rate to meet data transmission requirements, such as 100Mbps (which can be flexibly adjusted according to the model data size), avoiding communication ports that conflict with other communication ports, and ensuring the transmission timeout time for real-time data transmission. Simultaneously, the bus topology can be configured as a star topology, with the system-level model as the central node and the component-level models as slave nodes. The communication links from the slave nodes are directed to the central node, completing the topology setup. After setup, test data is sent using a bus connectivity testing tool to verify the smooth communication links between the central node and each slave node, ensuring centralized control and efficient interaction of data transmission.

[0068] Next, the virtual projection node and data buffer are configured. First, the interface definition file of the component-level model is read, such as an XML-formatted interface description file. A parsing tool is used to extract the data type definitions of the output ports, such as floating-point, integer, and boolean types, along with the preset clock frequency parameters. Then, a data interface object is instantiated as a virtual projection node on the digital bus through programming. For example, a DataReader object can be created based on the DDS bus API in a C++ programming environment. The attributes of this data interface object, such as data bit width and data transmission format, must match the parsed output port data type definitions to ensure that data can be intercepted without distortion.

[0069] Next, the data interception rules for the virtual projection node are set. The trigger condition for data sampling can be set to be triggered when the data output port of the component-level model is updated. The sampling frequency is reasonably set according to the clock frequency of the component-level model and the simulation step size of the system-level model. For example, if the clock frequency of the component-level model is 1kHz and the simulation step size of the system-level model is 10ms, then the sampling frequency is set to 100Hz, that is, the component-level model output data is sampled once every 10ms to avoid excessive redundancy of high-frequency data.

[0070] Meanwhile, a dedicated memory area is allocated in the storage module of the digital bus as a data cache, the storage capacity of the cache is set, and the cumulative deviation value in the data cache is initialized to 0 through programming instructions, so as to provide an initial benchmark for subsequent deviation accumulation calculation.

[0071] Finally, complete the initialization verification, start the basic communication connection between the system-level model and the component-level model, and attempt to intercept the test data output by the component-level model through the virtual projection node. If the data can be successfully stored in the data buffer without data loss, format errors, or other issues, and the cumulative deviation value remains unchanged at the initial value of 0, it indicates that the configuration of the digital bus, virtual projection node, data buffer, and the initialization of the cumulative deviation value are all complete. If data transmission anomalies occur, it is necessary to re-check the interface definition parsing results, data interface object attribute configuration, and communication parameter settings until stable data interception and storage are achieved.

[0072] Through the implementation of S101 above, this application constructs a standardized and highly compatible cross-level data interaction channel, realizes the accurate interception and storage of component-level model data, provides a stable hardware and software foundation for subsequent data processing and collaborative control, effectively solves the problems of incompatible data interaction interfaces and asynchronous transmission in traditional cross-level modeling, and improves the reliability and real-time performance of data transmission.

[0073] Regarding S102 above:

[0074] See Figure 2 The flowchart of the feature extraction process provided in the embodiments of this application includes steps S201 to S203, wherein:

[0075] S201, the original time series data is sampled by a sliding window through the virtual projection node to obtain discrete data points of multiple consecutive time segments;

[0076] S202, for each discrete data point in a time segment, calculate statistical characteristic indicators, including one or more of the mean, variance, peak value, and root mean square value;

[0077] S203, perform dimensionality reduction mapping on the statistical feature indicators to generate semantic feature vectors.

[0078] In cross-level collaborative design, the raw time series data output by the component-level model is usually characterized by high frequency, transient nature, large data volume, and a large amount of redundant noise. The system-level model focuses on macro performance indicators. If the raw time series data is directly transmitted to the system-level model, it will not only consume a lot of computing resources and transmission bandwidth, but also cause the system-level model to overreact to irrelevant transient fluctuations due to data semantic mismatch, thus triggering collaborative iteration oscillations.

[0079] In step S102 of this embodiment, feature extraction and semantic mapping are performed on the original time-series data through virtual projection nodes. This transforms the high-frequency, redundant original data into low-frequency feature vectors that reflect core semantic information, thereby filtering out redundant noise and achieving data semantic unification, providing an adapted data format for efficient processing of upper-level system-level models.

[0080] The original time-series data consists of continuously changing physical quantity data output by the component-level model based on continuous-time differential equations, such as millisecond-level data sequences of voltage, current, and torque. Sliding window sampling refers to a sampling method that sets a fixed-length time window and slides it across the original time-series data sequence at certain step sizes to extract continuous time segments of data.

[0081] Statistical characteristic indicators are quantitative indicators that can reflect the distribution and variation patterns of data. The mean is used to describe the central tendency of the data, the variance is used to describe the dispersion of the data, the peak value is used to describe the maximum value in the data, and the root mean square value is used to describe the magnitude of the effective value of the data.

[0082] Dimensionality reduction refers to the process of transforming high-dimensional statistical features into low-dimensional vectors. The aim is to remove redundant correlations between features while retaining core information. Semantic feature vectors, after feature extraction and dimensionality reduction, are low-dimensional vectors that can represent the core semantic information of the original time-series data; each dimension component corresponds to a core feature.

[0083] In the specific implementation, sliding window sampling is first performed. Based on the preset sampling frequency and window parameters in the virtual projection node, the sliding window sampling operation is performed on the intercepted original time series data. The window length is set to be an integer multiple of the clock cycle of the component-level model. The window slides on the original time series data sequence through programming. After each slide, discrete data points in the window are intercepted, and finally a set of discrete data points corresponding to multiple continuous and partially overlapping time segments is obtained.

[0084] Next, statistical characteristic indicators are calculated. For discrete data points within each time segment, the calculation of statistical characteristic indicators is implemented through programming. If the data is voltage time series data, for a time segment including multiple data points, the mean is calculated first, which is the arithmetic mean of all data points. Then, the variance is calculated, which is the average of the sum of squares of the differences between each data point and the mean. Then, the peak value is extracted, which is the maximum value among the data points. Finally, the root mean square value is calculated, which is the square root of the average of the sum of squares of each data point. A set of high-dimensional statistical characteristic indicators including mean, variance, peak value and root mean square value is generated for each time segment.

[0085] Then, dimensionality reduction mapping is performed to generate semantic feature vectors. Two implementation methods can be selected. The first is the linear projection transformation algorithm, which can use the principal component analysis (PCA) algorithm. First, the statistical feature indicators of all time segments are standardized, and each indicator is transformed into standardized data with a mean of 0 and a variance of 1. Then, the covariance matrix of the standardized data is calculated, and the eigenvalues ​​and eigenvectors of the covariance matrix are solved. The eigenvectors are used as basis vectors, and the projection value of each statistical feature indicator on the basis vector is calculated. A preset variance contribution rate is set, and the top M projection components with a cumulative variance contribution rate that reaches the preset variance contribution rate are selected. The semantic feature vector is composed of these M projection components.

[0086] The variance contribution rate is set according to the dimensionality reduction objective of the PCA algorithm, namely, to remove redundant correlations in statistical feature indicators while preserving the core semantics of the original time series data to the greatest extent possible, adapting to the actual needs of cross-level collaborative design. The value is usually in the range of 80%-95%. Specifically, if it is necessary to prioritize feature integrity, it can be set to 90%-95%; if it is necessary to prioritize reducing data dimensionality to improve computational efficiency, it can be set to 80%-85%.

[0087] The second approach is the neural network encoder method. This method uses a pre-trained autoencoder as the neural network encoder, constructing a sample set containing historical operational data from a large number of similar components. This sample set covers time-series data of the components under different operating conditions, such as startup, steady state, and fault edge. The aforementioned statistical feature indicators are pre-calculated on the sample set data as training input. The autoencoder has been trained using statistical feature indicators corresponding to the time-series data of a large number of similar components. The input layer dimension is consistent with the statistical feature indicator dimension, the hidden layer dimension is set to M dimensions, and the output layer dimension is consistent with the input layer dimension. During the training phase, the statistical feature indicators are used as both input to the input layer and reconstruction targets for the output layer. Mean squared error is used as the loss function, and the network weights are iteratively updated using the backpropagation algorithm until the reconstruction error of the output layer converges to a preset range. The currently calculated statistical feature indicators are input to the pre-trained autoencoder, and the output values ​​of the hidden layer are extracted as semantic feature vectors. The choice between these two methods depends on actual computing power and accuracy requirements. When computing power is limited, the PCA algorithm is preferred; when higher accuracy is required for feature representation, the neural network encoder method is chosen.

[0088] Finally, feature vector verification is performed, calculating the dimension and data integrity of the semantic feature vector to ensure that its dimension meets the preset requirements and that there are no missing or outlier values. If there are outliers, the sampling parameters or dimensionality reduction algorithm parameters are re-checked until a qualified semantic feature vector is generated.

[0089] By implementing step S102, this application transforms the original time-series data into semantic feature vectors, effectively filtering out redundant noise and irrelevant transient fluctuations in the original data, reducing the computational power consumption for data transmission and subsequent processing, and simultaneously achieving semantic adaptation between the underlying data and the upper-level model. This avoids the problem of collaborative iteration oscillation caused by the data semantic gap, and improves the efficiency and effectiveness of cross-level data interaction.

[0090] Regarding the above S103:

[0091] See Figure 3 The flowchart for generating a sensitivity factor provided in this application embodiment includes steps S301 to S303, wherein:

[0092] S301, a test bias of a preset value is superimposed on each dimension component of the semantic feature vector to generate a test feature vector.

[0093] S302, Input the test feature vector into the system-level model and record the numerical changes in the target parameters;

[0094] S303, calculate the ratio of the numerical change to the test bias, and use it as the sensitivity factor for the corresponding dimension component.

[0095] In cross-level collaborative design, the degree of dependence of the target parameters of the system-level model on the data of the underlying components varies. Existing technologies lack quantitative assessment of this dependence, which leads to minor changes in non-critical data triggering system-level recalculation, resulting in wasted computing power and low iteration efficiency. At the same time, it is impossible to accurately measure the actual impact of data changes on the system-level model.

[0096] In step S103 of this embodiment, the core target parameters of the system-level model are first accurately located, and then the dependence of the target parameters on each dimension of the semantic feature vector is obtained through quantitative calculation. It should be noted that the sensitivity factor generation operation in step S103 is preferably performed once during the initialization phase or offline preprocessing phase of cross-level collaborative simulation, rather than being calculated in real time at each simulation time step. This establishes the weight benchmarks for each dimension before the simulation begins, avoiding the loss of computational savings from silent updates due to repeated calls to the system-level model to calculate sensitivity during real-time simulation. Combined with the actual change in the semantic feature vector, a weighted change impact value reflecting the actual impact of data changes on system performance is calculated, providing a quantitative basis for whether to trigger subsequent collaborative iterations.

[0097] In this model, the target parameters are variables marked as key performance indicators, such as task completion rate, average power, and response time, directly reflecting the overall system performance. The sensitivity factor is a coefficient that quantifies the dependence of the target parameters on each dimension of the semantic feature vector; a larger sensitivity factor indicates a more significant impact of changes in that dimension on the target parameters. The change amount represents the degree of difference between the current semantic feature vector and the historical semantic feature vector, characterizing the magnitude of data change. The weighted change impact value is the product of the change amount and the sensitivity factor, comprehensively reflecting the actual impact of data changes on the target parameters.

[0098] In practice, the target parameters of the system-level model are first obtained, and the variable list of the system-level model is traversed. For example, the variable list is exported through the model variable browser in MATLAB Simulink. Based on the attribute tags of the variables, the variables marked as key performance indicators are selected. For example, in the automotive electronic system-level model, variables such as fuel consumption per 100 kilometers, maximum speed and acceleration time are selected as monitoring objects.

[0099] By using the signal tracing function of the model simulation tool, the signal transmission path between the system-level model input port and the monitored object variable is established, clarifying which modules and operations the input data passes through before acting on the monitored object variable. For example, the engine output torque (input port data) passes through the transmission system module and the driving resistance module before acting on the maximum vehicle speed (monitored object variable).

[0100] The signal transmission path is not a simple data reading channel, but a bidirectional test stimulus link. Specifically, during the sensitivity factor calculation phase, this path injects the test feature vector, superimposed with test bias, into the system-level model and transmits back the response values ​​of the monitored object variables in real time, thereby achieving automated closed-loop sensitivity analysis. In the subsequent co-simulation phase, this path continuously monitors the target parameters to verify the current simulation state.

[0101] At the current simulation step size, the real-time values ​​of the monitored object variables are read through the model interface function. For example, if the current simulation step size is 0.1 seconds, the maximum vehicle speed at this time is read as 120 km / h, and this value is determined as the target parameter.

[0102] Next, the sensitivity factor is calculated for the generated semantic feature vector. Assume the semantic feature vector is n-dimensional (n≥1), with each dimension component being f1, f2, ..., f... n First, determine the current baseline value f1 for each dimension component. 0 f2 0 ... f n 0 The preset test bias is set to a preset ratio α of the current baseline value of each dimension component. α is a constant greater than 0 and less than 1, which can be adjusted according to the simulation accuracy requirements. Then, the test bias corresponding to the i-th dimension (i=1, 2, ..., n) is Δf. i =α×f i 0 .

[0103] For each dimensional component f i The corresponding test bias Δf is superimposed on this dimension. i The remaining dimensional components remain unchanged from the current baseline values, generating n sets of test feature vectors V1, V2, ..., V n , where the i-th test feature vector V i The i-th dimension component is f i 0 +Δf i The remaining dimensional components are f j 0 (j≠i). V represents the test feature vector for each group. i Input the system-level model separately, keeping other input parameters constant, run the simulation and record the numerical change ΔP of the objective parameter P. i ΔP i =P i -P0, where P0 is the input baseline feature vector V 0 =[f1 0 f2 0 , ..., f n 0The initial value of the target parameter P at time ] i For the input test feature vector V i The measured values ​​of the target parameters at that time. Calculate the sensitivity factor S corresponding to each dimension component. i =ΔP i / Δf i This ultimately forms the sensitivity factor vector S = [S1, S2, ..., S...]. n ].

[0104] Then, to monitor the changes in the semantic feature vector, the semantic feature vector V stored in historical time periods is retrieved first through the data cache read interface. k-1 =[f 1(k-1) f 2(k-1) , ..., f n(k-1) Simultaneously, obtain the semantic feature vector V generated at the current time. k =[f 1k f 2k , ..., f nk Here, k represents the time step, used to distinguish semantic feature vectors at different times. k = k-1 represents a historical time or the previous data update cycle / simulation time step, and k = k represents the current time. The numerical differences between the current vector and the historical vectors are calculated in each dimension, with the difference in the i-th dimension being Δf. ik =f ik -f i(k-1) This leads to the difference vector ΔV. k =[Δf 1k , Δf 2k , …, Δf nk Then, using distance metric functions such as Euclidean distance and Manhattan distance, the difference vector ΔV is calculated. k The scalar magnitude is defined as the change ΔV of the semantic feature vector. kmag , ΔV kmag In this context, "mag" is an abbreviation for "magnitude," representing the scalar magnitude, indicating that the change is the magnitude of the difference vector rather than the vector itself. Specifically, the distance metric function preferably uses the Euclidean distance formula, which is calculated as follows:

[0105]

[0106] Where, Δf ik Let ΔV be the difference between the values ​​of the i-th dimension at the current time and at the previous time. kmag The scalar modulus of the calculated change.

[0107] Finally, the weighted change impact value is calculated, and the difference vector ΔV is used. kThe sensitivity factor vector S is weighted and fused. To convert the multi-dimensional vector into a single scalar evaluation index, this embodiment uses a weighted absolute value summation method. The calculation formula is as follows:

[0108]

[0109] Among them, |Δf ik | represents the absolute value of the numerical difference in the i-th dimension, S i Sensitivity factor for the corresponding dimension

[0110] This calculation yields a quantitative indicator that comprehensively reflects the impact of changes in various dimensions on the target parameters.

[0111] By implementing step S103, this application achieves precise positioning of target parameters, quantitative calculation of sensitivity factors, and evaluation of weighted change impact values. It clarifies the actual impact of data changes on the key performance of the system-level model, solves the problem of invalid synchronization caused by the lack of sensitivity discrimination in traditional collaborative design, makes subsequent collaborative iteration triggering more targeted, reduces the computing power consumption caused by invalid iterations, and improves the efficiency of cross-level collaborative design.

[0112] Regarding S104 above:

[0113] In cross-level collaborative iterative decision-making, considering only the impact of a single data change or using a fixed threshold for judgment can lead to an impact on design accuracy due to ignoring cumulative deviations, or cause over-iteration or under-iteration due to the threshold not matching the requirements of the simulation stage.

[0114] In step S104 of this embodiment, the weighted impact of the current data change and the cumulative effect of historical deviation are combined to calculate the estimated cumulative deviation value. At the same time, the collaborative tolerance threshold is dynamically determined according to the accuracy requirements of the current simulation stage of the system-level model. Through the comparison of the dual thresholds, a basis is provided for the decision of subsequent silent update or forced synchronization.

[0115] The cumulative deviation value is the accumulated deviation stored in the data cache that did not trigger forced synchronization during previous silent updates. The estimated cumulative deviation value is the sum of the current weighted change impact value and the historical cumulative deviation value, representing the combined effect of a single change and the accumulation of historical deviations. The collaborative tolerance threshold is determined based on the accuracy level of the current simulation stage of the system-level model; it is the maximum allowable deviation value. Exceeding this threshold triggers forced synchronization.

[0116] In practice, the estimated cumulative deviation value is first calculated. The current stored cumulative deviation value is obtained through the data cache read interface. Combined with the weighted change impact value obtained in step S103, the estimated cumulative deviation value is calculated according to the principle that the estimated cumulative deviation value equals the weighted change impact value plus the cumulative deviation value.

[0117] Next, the preset collaborative tolerance threshold is determined. First, the simulation configuration table of the system-level model is read. This configuration table is standardized tabular data pre-set and stored in the model configuration file, including multiple logical simulation stages, such as the conceptual design stage, detailed design stage, and verification stage. The stage division can be defined according to the specific R&D process. It also includes corresponding accuracy level parameters, which are quantitative indicators characterizing the design accuracy requirements. The higher the accuracy requirement, the more stringent the corresponding parameter value. Specifically, the simulation configuration table is constructed as a two-dimensional lookup matrix structure. The row index of the matrix corresponds to the preset simulation stage, such as the scheme design stage, detailed design stage (i.e., verification stage), and the column index corresponds to the accuracy level, such as Level 1 (coarse), Level 2 (standard), and Level 3 (high precision). The cells in the table store fixed threshold values ​​obtained through pre-calibration or training with historical data. For example, in the scheme design stage with an accuracy level of Level 1, the corresponding threshold is larger to allow for a wider design exploration space; in the verification stage with an accuracy level of Level 3, the corresponding threshold is extremely small to ensure the accuracy of the final result.

[0118] Next, the timing identifier information of the current simulation time step is obtained through model simulation tools. Combined with the stage division rules of the overall simulation process, such as division based on simulation duration percentage or key node completion status, the current target simulation stage is identified. The accuracy level parameter corresponding to the target simulation stage is extracted from the simulation configuration table. Through mapping rules, the current collaborative tolerance threshold is calculated, and the threshold matches the accuracy requirement of the current stage. The mapping rule is a one-way mapping function from accuracy level to tolerance threshold, preferentially using linear mapping or piecewise linear mapping. If the accuracy level parameter is a continuous value, linear mapping is used; if the accuracy level parameter is a discrete level, piecewise mapping is used, assigning a fixed tolerance threshold to each discrete level. The higher the level, the smaller the threshold.

[0119] Then, a threshold comparison is performed. The weighted change impact value and the estimated cumulative deviation value calculated in step S103 are compared with the collaborative tolerance threshold. First, it is determined whether the weighted change impact value is less than the collaborative tolerance threshold, and simultaneously, it is determined whether the estimated cumulative deviation value is less than the collaborative tolerance threshold. If both judgments are yes, it is determined that the immediate impact of the current data change and the historical deviation accumulation effect are both within the allowable range, and a decision instruction to execute a silent update is output, triggering the subsequent operation process S105. If either judgment is no, it is determined that the current data change or deviation accumulation has exceeded the accuracy allowable range, and a decision instruction to execute forced synchronization is output, triggering the subsequent operation process S106.

[0120] Regarding the above S105:

[0121] If the system-level model recalculation is triggered when the immediate impact of data changes and the cumulative historical deviations do not exceed the allowable range of accuracy, it will cause redundant consumption of computing resources, interrupt the normal simulation rhythm, and reduce the efficiency of collaborative design.

[0122] In this embodiment, silent update operation refers to a non-intrusive operation that updates data and deviation values ​​only within the data cache without triggering system-level model recalculation. The historical semantic feature vector is the semantic feature vector from the previous update cycle stored in the data cache, representing the input data upon which the system-level model currently operates. The current semantic feature vector is the latest semantic feature vector generated at the current moment after feature extraction and dimensionality reduction.

[0123] In the specific implementation, firstly, the cumulative deviation value is updated. Through the standardized write interface of the data cache, the estimated cumulative deviation value determined in S104 is completely overwritten with the historical cumulative deviation value originally stored in the data cache. The updated data cache will use the estimated cumulative deviation value as the new deviation accumulation benchmark to ensure that subsequent deviation calculations can be based on the latest accumulation status.

[0124] Next, the semantic feature vector cache is updated. Through the write interface of the same data cache area, the latest semantic feature vector generated at the current moment is overwritten with the historical semantic feature vector stored in the original storage, so that the data cache area always maintains the timeliness of the semantic feature vector, and provides accurate benchmark data support for the next round of change monitoring, sensitivity factor calculation and other processes.

[0125] Finally, the semantic feature vector from the previous time step is returned to the system-level model, maintaining the interception of the system-level model recalculation trigger signal. Specifically, although the latest semantic feature vector has been written into the data buffer, at the logic control level of the digital bus, because the S104 decision result is a silent update, the input interface of the system-level model is locked at the data state of the previous time step. When the system-level model reads input within the current simulation step, the digital bus does not push the latest data that was just written to the system-level model, but instead returns the historical semantic feature vector before the change occurred, i.e., the semantic feature vector from the previous time step, based on the pre-stored records.

[0126] In this way, this application completes the storage of the latest data in the data cache through silent update operation, ensuring the accuracy of the next calculation benchmark; however, at the logical interaction level, the input perceived by the system-level model remains unchanged, so no recalculation trigger signal is generated, thereby maintaining the interception state of the signal, making the data of the system-level model stable within the step size, avoiding frequent interruption of simulation due to small fluctuations in the underlying data, reducing the consumption of computing resources for cross-level collaborative simulation, and achieving a dual guarantee of collaborative design efficiency and data integrity.

[0127] Regarding S106 above:

[0128] The execution of the forced synchronization instruction output in response step S104 means that if the immediate impact of data changes or the accumulation of historical deviations exceeds the allowable range of accuracy, and the latest data is not synchronized to the system-level model in a timely manner, the calculation results of the system-level model will deviate too much from the actual component state, thereby affecting the accuracy and reliability of cross-level collaborative design, and even triggering a chain of errors in subsequent design iterations.

[0129] In this embodiment, the interrupt signal is a control signal used by the instruction system-level model to pause the current simulation step, ensuring the stability of the simulation state during data updates. The recalculation trigger signal is a control signal used by the instruction system-level model to re-execute calculations based on new input data.

[0130] In practice, firstly, an interrupt signal is sent to pause the simulation. This is done via the control channel of the digital bus, sending a standardized interrupt signal that conforms to the control protocol specifications supported by the system-level model. Upon receiving the interrupt signal, the system-level model pauses the currently executing simulation step and freezes current simulation state parameters, such as calculation progress and intermediate variable values, to prevent data inconsistencies or calculation errors caused by the continued simulation during data updates.

[0131] Next, the latest data is synchronously pushed. Through the data transmission channel of the digital bus, the latest semantic feature vector generated at the current moment is written to the input interface corresponding to the system-level model. Then, the cumulative deviation value is reset. Through the standardized write interface of the data buffer, the cumulative deviation value stored in the data buffer is reset to the initial baseline value, eliminating the interference of historical deviation accumulation on subsequent collaborative decision-making and establishing a new baseline starting point for the next round of deviation monitoring and cumulative calculation.

[0132] Finally, a system-level model recalculation is triggered. First, the previously sent interrupt signal is revoked via the control channel of the digital bus, releasing the simulation pause state of the system-level model. Then, a standardized recalculation trigger signal is sent, instructing the system-level model to re-execute the currently paused simulation step or the next simulation step based on the newly written semantic feature vector. After receiving the recalculation instruction, the system-level model will recalculate based on the new input data, update the values ​​of relevant target parameters, and achieve synchronization of cross-level collaborative iteration, ensuring that the calculation results of the system-level model are consistent with the actual state of the component-level model.

[0133] In this way, by performing a forced synchronization operation, this application achieves rapid response and precise synchronization when data changes exceed the threshold, curbing the further expansion of design deviations and ensuring the accuracy and reliability of cross-level collaborative design. At the same time, by resetting the cumulative deviation value, it provides a clear benchmark for subsequent collaborative decisions, ensuring that cross-level collaborative design can continue to advance under the premise of controllable accuracy and avoiding design failures caused by the accumulation of deviations.

[0134] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features therein. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this application.

Claims

1. A cross-level modeling and collaborative design method based on a digital bus, characterized in that, include: Establish a digital bus between the system-level model and the component-level model, configure virtual projection nodes and data buffers, and initialize the cumulative deviation value in the data buffers; The raw time-series data output by the component-level model is intercepted by the virtual projection node, and feature extraction processing is performed to map the raw time-series data into semantic feature vectors. Obtain the target parameters of the system-level model, calculate the dependence of the target parameters on the semantic feature vector, and generate a sensitivity factor; monitor the amount of change in the semantic feature vector, calculate the product of the amount of change and the sensitivity factor, and obtain the weighted change impact value. Obtain the current cumulative deviation value in the data cache, calculate the sum of the weighted change impact value and the cumulative deviation value to obtain the estimated cumulative deviation value; compare the weighted change impact value and the estimated cumulative deviation value with the preset collaborative tolerance threshold respectively; In response to the fact that both the weighted change impact value and the estimated cumulative deviation value are less than the collaborative tolerance threshold, a silent update operation is performed to update the value of the semantic feature vector in the data cache and intercept the recalculation trigger signal sent to the system-level model. In response to the weighted change impact value or the estimated cumulative deviation value being greater than or equal to the collaborative tolerance threshold, a forced synchronization operation is performed, the updated semantic feature vector is pushed to the system-level model, cross-level collaborative iteration is triggered, and the cumulative deviation value is reset.

2. The cross-level modeling and collaborative design method based on a digital bus according to claim 1, characterized in that, The digital bus is configured with virtual projection nodes and a data buffer, including: Read the interface definition file of the component-level model and parse the data type definition and preset clock frequency parameters of the output port; Instantiate a data interface object on the digital bus as a virtual projection node; the properties of the data interface object match the data type definition of the output port; Set data interception rules for virtual projection nodes, including the trigger conditions and frequency of data sampling.

3. The cross-level modeling and collaborative design method based on a digital bus according to claim 1, characterized in that, The feature extraction process includes: The original time-series data is sampled by a sliding window using the virtual projection node to obtain discrete data points for multiple consecutive time segments; For each discrete data point in a time segment, calculate one or more statistical characteristic indicators, including mean, variance, peak value, and root mean square value. The statistical feature indicators are dimensionality-reduced and mapped to generate semantic feature vectors.

4. The cross-level modeling and collaborative design method based on a digital bus according to claim 3, characterized in that, Dimensionality reduction mapping of the statistical feature indicators includes: Using a linear projection transformation algorithm, the projection values ​​of the statistical feature indicators on the basis vectors are calculated, and the projection components that satisfy the preset variance contribution rate are selected to form a semantic feature vector; or, the statistical feature indicators are input into a pre-trained neural network encoder, and the output values ​​of the hidden layer are extracted as the semantic feature vector.

5. The cross-level modeling and collaborative design method based on a digital bus according to claim 1, characterized in that, Obtain the target parameters of the system-level model, including: Traverse the variable list of the system-level model, filter out the variables marked as key performance indicators, and determine them as the monitoring objects. Establish a signal transmission path between the input port of the system-level model and the monitored object variable; Read the values ​​of the monitored object variables at the current simulation step size and use them as target parameters.

6. The cross-level modeling and collaborative design method based on a digital bus according to claim 1, characterized in that, Calculating the dependence of the target parameters on the semantic feature vector and generating a sensitivity factor includes: A test bias value with a preset value is superimposed on each dimension component of the semantic feature vector to generate a test feature vector. Input the test feature vector into the system-level model and record the numerical changes in the target parameters. The ratio of the numerical change to the test bias is calculated and used as the sensitivity factor for the corresponding dimensional component.

7. The cross-level modeling and collaborative design method based on a digital bus according to claim 1, characterized in that, Monitoring the changes in the semantic feature vector includes: Retrieve the historical semantic feature vector stored in the data cache; Calculate the numerical differences in each dimension between the semantic feature vector generated at the current moment and the historical semantic feature vector; The scalar magnitude of the numerical difference is calculated using a distance metric function, and the scalar magnitude is used as the change amount of the semantic feature vector.

8. The cross-level modeling and collaborative design method based on a digital bus according to claim 1, characterized in that, The preset cooperative tolerance threshold includes: Read the simulation configuration table of the system-level model, which includes the accuracy level values ​​corresponding to different simulation stages; Identify the simulation stage of the current simulation time step of the system-level model, and extract the value corresponding to the current simulation stage and accuracy level from the configuration table as the cooperative tolerance threshold.

9. The cross-level modeling and collaborative design method based on a digital bus according to claim 1, characterized in that, The silent update operation includes: Update the cumulative deviation value in the data cache, and write the estimated cumulative deviation value into the data cache to overwrite the original cumulative deviation value; Write the semantic feature vector generated at the current moment into the data cache area, overwriting the original data; Return the semantic feature vector from the previous time step to the system-level model, and maintain the interception state of the system-level model recalculation trigger signal.

10. The cross-level modeling and collaborative design method based on a digital bus according to claim 1, characterized in that, The forced synchronization operation includes: Send an interrupt signal to the system-level model to pause the current simulation step; The latest semantic feature vectors are written into the input interface of the system-level model via a digital bus; Reset the cumulative deviation value in the data buffer to zero; The interrupt signal is canceled and a recalculation trigger signal is sent. The instruction system-level model recalculates the current or next simulation step based on the written semantic feature vector.

Images