A heterogeneous design data processing method based on parameter dependency relationship
By establishing a unified data model and parameter dependencies, the problem of data silos between heterogeneous data systems is solved, enabling efficient cross-system collaborative processing and data consistency. It also supports domain experts in solidifying experience, reduces system expansion costs, and provides traceability capabilities.
Patent Information
- Application Number
- CN202611244525.9
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-08-17
- Publication Date
- 2026-11-10
AI Technical Summary
In engineering design, data silos exist between heterogeneous data processing systems, making it difficult to accumulate and reuse the experience of domain experts, lacking objective basis for parameter calling order, resulting in high costs for connecting new systems, lack of automatic correction capability for verification failures, invisible cross-system data flow, easy conflict of parameters with the same name, and difficulty in dynamically expanding and linking parameter attributes.
Establish a unified data model, configure globally unique identifiers for parameters, build a unified parameter access interface across systems, construct a directed acyclic graph based on parameter dependencies, record data flow records, support domain experts to build functional modules in a configuration manner, realize dynamic attribute expansion and change linkage, and detect and block naming conflicts.
It enables efficient collaborative processing of heterogeneous data systems, automatically schedules the order of parameter calls, supports the solidification of experience, ensures data consistency, reduces system expansion costs, provides traceability capabilities, and avoids conflicts between parameters with the same name.
Abstract
Description
Technical Field
[0001] This invention relates to the field of collaborative processing technology for heterogeneous design data in engineering design, and specifically to a method for processing heterogeneous design data based on parameter dependencies. Background Technology
[0002] In modern engineering design, the design process typically involves multiple heterogeneous data processing systems, such as 3D modeling systems, spreadsheet systems, computational analysis systems, and document processing systems. Each system independently stores and processes design parameters based on its own data structure, often forming data silos. Designers need to manually transfer parameters and verify calculation results repeatedly between different systems, and rely on professional programmers to write interfaces and calculation programs to connect various design functions. With the increasing scale and complexity of engineering designs, how to connect design parameters scattered across various systems and ensure the consistency and traceability of data flow has become a crucial issue facing the digitalization of engineering design.
[0003] Existing collaborative design data processing methods still have the following main shortcomings: Domain experts are excluded from application development, hindering the accumulation and reuse of design experience. The implementation of standard engineering design functions heavily relies on specialized software development, preventing engineering designers with domain knowledge from directly participating in function building. Their long-accumulated, experience-based data, which cannot be directly derived from engineering specifications or formulas, is often scattered in personal documents or relies on manual memory, making it difficult to solidify into reusable data processing logic. This leads to a tendency for the forward design data chain to break at experience-based nodes, and valuable engineering experience is difficult to reuse in subsequent projects.
[0004] The order of parameter calls lacks objective basis. There are input-output dependencies between functional modules, but in the conventional way, the execution order of modules mainly depends on human experience or is sorted according to subjective indicators such as dependency strength and call frequency. This makes it difficult to accurately reflect the real causal dependencies between engineering parameters, which can easily lead to disordered calculation order or inconsistent results between upstream and downstream.
[0005] Heterogeneous systems suffer from severe data silos, and the cost of integrating new systems is high. The native data structures of various heterogeneous data processing systems are different. When a new type of system is introduced, it is usually necessary to reconstruct the integration logic separately, which is costly to expand. At the same time, functional modules are tightly coupled with specific project orchestrations, making it difficult to reuse them across projects.
[0006] The verification failure lacks automatic correction capabilities. When the output parameters of a node do not meet the preset specifications, the existing methods usually rely on manual troubleshooting along the data chain segment by segment and recalculating the entire chain, or performing state rollback based on version snapshots. The former is inefficient and prone to introducing human error, while the latter only restores the historical data state rather than re-deriving and calculating based on parameter dependencies, and cannot automatically locate the upstream root cause along the dependencies and drive downstream cascading recalculation.
[0007] Cross-system data transfer is invisible and difficult to trace. When parameters flow between different systems, there is a lack of unified and complete transfer records. Once the results are abnormal, it is difficult to trace back the original data source and the transfer path, and cross-module data consistency is difficult to guarantee.
[0008] Cross-module and cross-system parameters with the same name are prone to conflict. In scenarios where multiple people collaborate and functional modules are built through configuration, data items imported by different designers or different systems may use the exact same name, or use semantically equivalent names to point to the same quantity of work. Since the unified registration mechanism can only guarantee that each piece of data has a unique, non-repeating global identifier, it cannot guarantee semantic uniqueness. Reference relationships can easily become confused, leading to data chain errors or distorted tracing.
[0009] Parameter attributes are difficult to dynamically expand and link. In actual engineering, design parameters often need to be supplemented with expanded attributes, and changes to a certain attribute require triggering related modules to recalculate. Existing methods lack an automatic propagation mechanism, and the dynamic expansion and change linkage of attributes largely rely on manual processing, which is prone to omissions and difficult to guarantee consistency.
[0010] The aforementioned shortcomings result in low efficiency, difficulty in ensuring consistency, difficulty in accumulating and reusing domain expert experience, and difficulties in system expansion and function reuse in the collaborative processing of engineering design data. Therefore, there is an urgent need for a data processing method that can connect multiple heterogeneous data processing systems, automatically coordinate data flow and calculation based on the objective dependencies between parameters, support domain experts in building and solidifying their experience through configuration, and possess traceability and scalability. Summary of the Invention
[0011] In the field of engineering design, design parameters scattered across various heterogeneous data processing systems form data silos and suffer from at least one of the following technical problems: domain experts are excluded from application development, making it difficult to retain and reuse their long-accumulated design experience; the parameter calling order between functional modules lacks objective basis; the integration cost is high when adding a new type of heterogeneous data processing system, and functional modules are tightly coupled with engineering orchestration, making them difficult to reuse; when the output of a certain node does not meet the specifications, there is a lack of automatic correction capability along the dependency relationship; cross-system data flow is invisible and difficult to trace; parameters with the same name across modules or systems are prone to conflict and reference relationships are chaotic; parameter attributes are difficult to dynamically expand and changes cannot be automatically linked.
[0012] To address the aforementioned issues, the present invention aims to provide a heterogeneous design data processing method, system, and computer-readable storage medium based on parameter dependencies. This method connects various heterogeneous data processing systems, automatically coordinates data flow and computation based on objective dependencies between parameters, supports domain experts in participating in application construction through configuration, and solidifies their experience into reusable data processing logic. It also possesses traceability and scalability.
[0013] Technical solution A first aspect of the present invention provides a method for processing heterogeneous design data based on parameter dependencies, characterized by comprising the following steps: S1. Establish a unified data model for engineering design parameters, configure attribute metadata for each parameter including identifier, name, data type, level, ownership, source, destination and association, and assign a globally unique identifier to each parameter based on a unified naming rule; S2. Based on the unified data model, establish a unified parameter access interface across multiple heterogeneous data processing systems; S3. Specify a parameter exchange format that is independent of the heterogeneous data processing system; S4. Construct a directed acyclic graph based on the input-output dependencies between parameters, with functional modules as nodes and parameter flow directions as edges, and bind corresponding data processing logic to each node; according to the topological order of the directed acyclic graph, trigger the execution of the node when the output parameters of the predecessor node meet the constraints, and backtrack along the dependencies and re-execute the affected node when the node output does not meet the preset specifications. S5. The computing tasks of each node are sent to the heterogeneous data processing system that carries the corresponding data processing logic for execution, and the execution results are written back to the unified data model. S6. During each cross-system parameter transfer, record the data source system, target system, transfer timestamp, data change content, parameter unique identifier and transfer type, and generate a data transfer record.
[0014] In a preferred embodiment of the present invention, the method may further include one or more of the following technical features: Establish a corresponding unified parameter access interface for each type of heterogeneous data processing system, and encapsulate parameter format conversion, calling and result parsing; when adding a new type of system, simply establish the corresponding interface and declare its functional modules and parameter dependencies to include it in the scheduling scope of the unified parameter access interface. The dynamic backtracking specifically includes: determining the set of all affected downstream nodes along the reverse path of the dependency relationship in the directed acyclic graph, adjusting the input parameters or calculation conditions of the upstream node, re-executing the upstream node and all its downstream nodes, and writing the results back to the unified data model, triggering the recalculation of downstream related parameters, until the output of all nodes meets the specification requirements. Each cross-system data transfer records the source system, target system, transfer timestamp, data change content, unique parameter identifier, and transfer type. Based on the recorded information, a visual data transfer link is constructed, and in response to traceability requests, the link is traced back node by node for investigation. The directed acyclic graph uses functional modules as nodes and parameter flow directions as edges. The activation condition of any node is that the output parameters of all its predecessor nodes satisfy the constraints. The data processing logic is bound to the data node to generate the output parameters of that node. The parameter exchange format, which is independent of heterogeneous data processing systems, is based on the attribute metadata definition of a unified data model and supports bidirectional reading and writing of parameters between heterogeneous data processing systems. It also includes the module embedding step: defining the inclusion relationship between functional modules and basic functions, sorting out the logical relationship between modules, and filling the module data into a three-level database architecture, which includes a platform framework database, a current project database, and a functional database. The data processing logic includes two categories: standard derivation logic and experience-based consolidation logic. The experience-based consolidation logic reserves a data processing logic binding interface for experience-based data items. For experience-based data that cannot be directly calculated from engineering specifications or formulas, the platform pre-encapsulates macros or programming interfaces through the table processing system, consolidating and registering them as reusable data processing logic and binding them to the binding interface. The macros or programming interfaces are provided by the platform, allowing engineering designers to complete experience accumulation without writing program code themselves. It also includes a naming conflict detection step: conflict detection is performed on data item names from different functional modules or different heterogeneous data processing systems. A three-level progressive detection method is used, which includes exact matching, semantic equivalence of the thesaurus, and edit distance similarity. Detected conflicts are blocked and a global reference index table is maintained. All modules that reference the data are notified when any data name is changed. It also includes dynamic attribute expansion and change linkage steps: the unified data model supports dynamic attribute expansion through key-value expansion tables; when any data item attribute changes, it is pushed to all subscribed modules in a publish-subscribe manner through the event bus and triggers the linkage recalculation or prompt of related parameters; the three-level database architecture follows a preset data flow protocol between each level and ensures data consistency through two-phase commit. The construction of the functional modules is completed by engineering designers by declaring the parameter dependencies between each functional module, binding the corresponding data processing logic to the data nodes, and configuring the data links within and between modules, without writing program code; the engineering designers are domain experts who are not software development professionals, and they assemble real and usable design functions through their configuration operations in a pseudo-programming manner, and solidify their design experience into reusable data processing logic.
[0015] A second aspect of the present invention provides a heterogeneous design data processing system based on parameter dependencies for implementing the aforementioned method, comprising: a data model module, a unified parameter access module, a format standardization module, a dependency graph derivation and scheduling module, an execution module, a flow record module, and a platform and user interface module; wherein the platform and user interface module is used to provide a visual display of module selection, parameter input, dependency configuration, execution status, and data flow links.
[0016] A third aspect of the present invention provides a computer-readable storage medium storing computer program instructions that, when executed by a processor, implement the aforementioned heterogeneous design data processing method based on parameter dependencies.
[0017] Beneficial effects The present invention has the following advantages over the prior art: Connect heterogeneous data processing systems to reduce expansion and reuse costs. By establishing a unified data model and a unified parameter access interface across multiple systems, the differences in the native data structures of various heterogeneous data processing systems are shielded. When adding a new type of system, only the corresponding interface needs to be established and the module and dependencies declared to be included in the scheduling, without the need to reconstruct the interface logic for each type of system separately; functional modules are decoupled from specific project orchestration and can be reused across projects.
[0018] The execution order is automatically deduced from the objective dependencies of the parameters. A directed acyclic graph is constructed based on the input-output dependencies between parameters, and the scheduling is driven by these dependencies. This ensures that the execution order of modules automatically matches the actual causal chain of the project, avoiding order confusion and inconsistencies caused by manual scheduling or subjective scoring based on dependency strength, call frequency, etc.
[0019] Verification failures can be automatically corrected by backtracking. When a node's output does not meet the specification, the system backtracks along the dependency relationship and re-executes the affected node and its downstream nodes, achieving a closed loop of parameter re-derivation and cascaded recalculation. This eliminates the need for manual full-chain recalculation and differs from rollback methods that only restore historical data states, significantly improving correction efficiency and consistency.
[0020] Cross-system data transfer is traceable. Each cross-system parameter transfer records six types of fields and constructs a visual link. Any final output can be traced back node by node to check its original data source and previous transfer paths, ensuring data consistency across modules.
[0021] It supports domain experts in using pseudo-programming to participate in building and solidifying their experience. Experience-based data is solidified and registered as reusable data processing logic. Engineering designers do not need to write program code; they can assemble real and usable functions by declaring dependencies, binding logic, and configuring links. This allows long-term accumulated engineering experience to be preserved and reused, and the forward design data chain has a definite source at each stage without interruption.
[0022] Ensure naming uniqueness and reference consistency. Perform three-level progressive conflict detection and blocking on data item names imported across modules and systems, maintain a global reference index table and change notifications, avoid reference confusion caused by identical or semantically equivalent names, and complement the unique identifier guaranteed by the unified data model.
[0023] It supports dynamic expansion and change linkage. The unified data model supports the dynamic expansion of attributes through key-value expansion tables. Attribute changes are automatically linked to relevant modules for recalculation via event bus publish-subscribe. The three-level database architecture ensures consistency between levels through two-phase commit, enabling data organization to have sustainable expansion and automatic propagation capabilities. Detailed Implementation
[0024] The following provides a more detailed description of specific embodiments of the present invention. It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the scope of protection of the invention.
[0025] It should be noted that: (1) The “heterogeneous data processing system” mentioned in this invention refers to various engineering design data processing entities with different native data structures, such as three-dimensional modeling systems (e.g., 3DE, CAD, Revit), table processing systems (e.g., Excel), calculation and analysis systems, document processing systems (e.g., Word), etc.; the “data processing logic” refers to the calculation rules used to generate engineering parameters, including two types: normative derivation logic and experience-based logic; the “pseudo-programming” refers to the fact that domain experts do not need to write program code, but only build functional modules by declaring parameter dependencies, binding existing data processing logic, and configuring data links; the “experience-based logic” refers to encapsulating the experience judgments of domain experts into reusable data processing logic. The specific system names mentioned above are only examples and do not constitute the necessary technical features of this invention.
[0026] (2) The method of the present invention is not limited to a specific engineering field. The following uses the collaborative calculation of a set of parameters in the design process of a pumped storage power station panel dam as an example to illustrate the present invention. Those skilled in the art can understand that the data collaborative processing method based on parameter dependency described in the present invention is also applicable to the design data processing of other types of projects (such as building structures, bridges, tunnels, etc.), and its underlying logic of "unified data model - dependency-driven scheduling - dynamic backtracking - flow traceability" has universality.
[0027] It should be noted that [N1], [N2], [N3], [N4], [N5], and [N6] in the following embodiments are merely textual identifiers for the nodes of the directed acyclic graph.
[0028] Example 1: This example demonstrates the end-to-end operation of the core method of the present invention in a complete engineering design calculation; Unified data model and globally unique identifier, Taking the design of a pumped storage concrete dam as an example, six parameter nodes with objective input-output dependencies are selected to form a computational chain: [N1] Verification of geological parameters of reservoir basin; [N2] Dam crest elevation; [N3] Warehouse capacity trial calculation; [N4] Three-dimensional modeling of dam cross-section; [N5] Calculation of project quantities; [N6] Anti-skid stability calculation.
[0029] Based on S1, the above parameters are configured in a unified data model with attribute metadata including identifier, name, data type, level, affiliation, source, destination and association. Each parameter is assigned a globally unique identifier based on a unified naming rule (for example, using a double prefix encoding system, assigning a globally unique name with "professional prefix - object prefix - parameter name"). Thus, parameters with the same name or similar meanings scattered in different heterogeneous data processing systems are converged into a unified semantic carrier.
[0030] Unified parameter access interface and parameter exchange format Based on S2, a unified parameter access interface is established for each of the various heterogeneous data processing systems participating in the computation: 3D modeling system (such as 3DE): Establish a unified access interface and encapsulate parameter format conversion, calling and result parsing of the system; Spreadsheet processing systems (such as Excel): Establish a unified access interface to encapsulate the reading and writing of spreadsheet cells and macro calls; Computational analysis systems (such as ANSYS): Establish a unified access interface to encapsulate the generation of computational input files, solution calls, and result extraction.
[0031] According to S3, attribute metadata based on a unified data model specifies a machine-readable intermediate exchange format that is independent of heterogeneous data processing systems, supports bidirectional reading and writing of parameters between systems, and provides a unified carrier for cross-system parameter transfer.
[0032] Building a dependency graph and dependency-driven scheduling A directed acyclic graph (DAG) is constructed based on the input-output dependencies between parameters: functional modules are used as nodes, and parameter flow directions are used as directed edges. Each node is bound to corresponding data processing logic (in this embodiment, node binding is a derivation-based data processing logic). The activation condition for any node is that the output parameters of all its predecessor nodes satisfy the constraints. Scheduling is based on the DAG topology: for example, the [N2] dam crest elevation output only triggers the [N3] reservoir capacity trial calculation after it satisfies the constraint (dam crest elevation ≥ 123.0m); the [N4] cross-section modeling depends on the [N3] reservoir capacity and the [N2] elevation, and is triggered after both are met. The computational tasks of each node are dispatched to a heterogeneous data processing system carrying the corresponding data processing logic for execution according to the schedule, and the execution results are written back to the unified data model.
[0033] In this embodiment, the node execution order is automatically derived from the objective input-output dependencies between engineering parameters, rather than relying on manually set dependency strength or priority scores. The advantage of this approach is that the scheduling order strictly matches the true causal chain between parameters, avoiding order confusion and repeated adjustments caused by subjective weight assignment, ensuring that cross-system computation always proceeds along the correct causal order. Those skilled in the art are accustomed to arranging computation order using dependency strength scores or manually set priorities in conventional data processing or design collaboration. They find it difficult to conceive of automatically deriving the execution order directly from the objective input-output dependencies of parameters, let alone integrating this objective dependency derivation with unified access, dynamic backtracking, and flow tracing across heterogeneous systems into a single method, thereby simultaneously solving three types of problems: unfounded computation order, lack of automatic correction for verification failures, and invisible flow processes.
[0034] Dynamic backtracking When the anti-sliding stability safety factor output of [N6] is 1.3, which does not meet the preset specification (≥1.5), the set of all affected downstream nodes is determined along the reverse path of the DAG dependency relationship (in this example, the upstream root cause node is [N4], and its affected downstream node set is [N4], [N5], and [N6]). The upstream node [N4] is back located (the cross-sectional size is too small, resulting in insufficient stability). The input parameters of [N4] are adjusted (the width of the dam cross-section is increased), and [N4] and all its downstream nodes [N5] and [N6] are re-executed according to the DAG. The result data generated by the re-execution is written back to the unified data model, and the associated parameters of its downstream nodes are triggered to be recalculated until the output parameters of all nodes meet the specification requirements (the safety factor reaches 1.5 or higher).
[0035] The retrospective mechanism of this invention is achieved through the re-derivation and recalculation of parameter dependencies, rather than through snapshot rollback or version-based restoration of historical states. The advantage of this approach is that when upstream data is corrected, all affected downstream parameters can be automatically cascaded and recalculated based on the dependency graph, maintaining consistency in the forward data chain without requiring manual node-by-node review. When faced with "calculation results not meeting specifications," those skilled in the art typically roll back to a historical snapshot or switch versions for recalculation, rarely considering tracing the affected upstream along the parameter dependency graph, driving downstream cascading recalculation through parameter re-derivation, and combining this retrospective mechanism with a unified data model and cross-system execution of write-back to form an automatic closed-loop correction.
[0036] Six-field flow record and traceability During each parameter transfer across heterogeneous data processing systems, the source system, target system, transfer timestamp, data change content, unique identifier of the transferred parameter, and transfer type (read / write / calculate / convert) are recorded. A data transfer record is generated, and a visualized data transfer link is constructed based on this record. When designers need to verify the source of the [N6] anti-sliding stability safety factor, the system responds to the traceability request and checks each node in reverse along the data transfer link. This allows the determination of the original data source ([N4] cross-sectional dimensions → [N3] reservoir capacity → [N2] dam crest elevation → [N1] reservoir parameters) and the previous transfer paths, supporting cross-module consistency verification.
[0037] The tracing records of this invention are bound to a parameter dependency graph and a dynamic backtracking mechanism. This not only allows designers to trace data sources node by node in reverse, but also serves as a closed loop for automatic recalculation when specifications are not met. The advantages of this approach are: every cross-system flow is accurately recorded; tracing and correction share the same dependency graph; and identified deviations immediately drive the recalculation of the corresponding node, rather than isolated queries. Those skilled in the art typically use tracing as a post-event verification and query tool in conventional data governance, and rarely consider unifying flow records, dependency graphs, and dynamic backtracking into a single data chain that can be traced backwards and driven forwards for recalculation, making tracing an integral part of automatic correction.
[0038] Example 2: Example 1 has solved three types of problems in the basic data chain: "undocumented calculation order, no automatic correction for verification failures, and invisible flow process." However, it still has some unaddressed technical issues: experience-based parameters in engineering cannot be directly obtained from specifications or formulas, are difficult to solidify into reusable logic, domain experts are excluded from application building, design experience is lost with personnel turnover, and similar data with the same name when imported from different modules or heterogeneous systems may cause crosstalk. This example further solves the technical problems not covered by Example 1: by reserving data processing logic binding interfaces for experience-based data items, domain experts can solidify their experience into reusable "building blocks" without programming, ensuring that each link in the positive data chain has a definite source and that experience-based nodes are no longer broken; through pseudo-programming (declaring dependencies, binding logic, configuring links), domain experts without programming skills can directly participate in function building; and through three-level cross-module and cross-system naming conflict detection, reference consistency is ensured. Compared to Example 1, this example expands the applicable boundary of the method from "parameters that can be derived from the standard" to "parameters that include empirical judgments", and significantly improves the data quality and experience reusability in multi-person collaboration.
[0039] Experience solidifies data processing logic In panel dam design, some parameters (such as the optimal value of the dam cross-sectional width) cannot be directly calculated from engineering specifications or formulas and belong to empirical data. A data processing logic binding interface is reserved for empirical data items. Designers (domain experts) can use the macro or programming functions of a spreadsheet system to solidify this empirical value rule into reusable data processing logic (empirical solidification module), and register and bind it to the corresponding empirical data item's binding interface for DAG nodes to call. Thus, the forward design data chain has a definite source of data processing logic at each stage, preventing breaks in empirical nodes; and engineering designers can complete the solidification of empirical modules without writing program code, transforming long-accumulated design experience into reusable "building blocks."
[0040] The advantage of this approach is that experiential parameters no longer rely on the memories of individual designers or scattered documents. Instead, they are embedded in the system as reusable data processing logic, ensuring consistent and reliable results for any designer who calls upon them. Those skilled in the art typically retain design experience through documents, templates, or manual operations, rarely considering reserving dedicated data processing logic binding interfaces for experiential data items. This allows domain experts to solidify their experience into computational logic that can be automatically invoked by the dependency graph without programming, and integrate it with the standard derivation logic into cross-system scheduling.
[0041] Domain expert pseudo-programming construction The construction of functional modules is completed by engineering designers (domain experts without programming expertise) through the following configuration operations, without writing program code: declaring the parameter dependencies between functional modules; binding corresponding data processing logic (standard derivation logic or experience-based modules) to data nodes; and configuring data links within and between modules. Through this pseudo-programming method, domain experts assemble, like building blocks, a truly usable design function that can run in a real heterogeneous data processing system and produce engineering data, thus solidifying design experience into reusable data processing logic. This is the core focus of this invention: pseudo-programming implemented at the data link rule layer, enabling domain experts to participate in application construction.
[0042] The advantages of this approach are: application development is no longer monopolized by software developers; domain experts with engineering experience but no programming skills can directly participate in feature building; and design experience continues to accumulate as the application layer expands. Those skilled in the art, in conventional low-code or design platforms, typically limit "configuration without programming" to interface or process orchestration. They rarely consider using three pseudo-programming steps—parameter dependency declaration, data processing logic binding, and data link configuration—to directly assemble functions that can run on real heterogeneous data processing systems and produce engineering data. Even more difficult is the idea of using a unified data model as a foundation to enable such pseudo-programming artifacts to be scheduled and backtracked via dependency graphs.
[0043] Naming conflict level 3 detection When data items from different functional modules or different heterogeneous data processing systems are imported into a unified data model, conflict detection is performed on the data item names using a three-level progressive detection method: Level 1 exact match detection: Determines whether the names of two data items are completely identical. For example, if both modules are named "Dam Crest Elevation", a conflict is detected. If no match is found, the second-level thesaurus semantic equivalence check is performed: the thesaurus is queried, for example, "upstream water level" and "H_up" are determined by the dictionary to be the same physical quantity, and are therefore considered to be in conflict; If no match is found, the third-level edit distance similarity detection is performed: the edit distance similarity between the two data names is calculated, and if it exceeds a preset threshold (such as 0.9), it is determined to be an approximate conflict.
[0044] Blocking detected naming conflicts and maintaining a global reference index table; when any data name changes, notifying all modules that reference that data to ensure consistency of references across modules and systems.
[0045] It should be noted that although S1 in claim 1 assigns a globally unique identifier to each parameter, this unique identifier is a machine-coded ID and does not guarantee that data from different sources will be identified as the same item when representing the same physical quantity at the semantic level. The naming conflict detection in this embodiment is specifically used to identify semantic-level name conflicts or near-semantic conflicts across modules and systems, which is complementary to, rather than redundant with, the unique coding of S1.
[0046] The advantage of this approach is that data with the same or similar names across modules and systems is promptly identified and blocked during import, preventing incorrect entries from being parsed, data chain breaks, or source tracing errors. Those skilled in the art, when establishing a unified data model, typically assume that assigning a globally unique identifier solves the data consistency problem. They rarely consider that in scenarios involving multiple users and multiple sources, it is still necessary to identify semantic-level conflicts using a three-tiered progressive approach: exact matching, semantic equivalence from a thesaurus, and edit distance similarity. Furthermore, conflict blocking should be linked to the global reference index and change notifications, serving as an independent quality assurance layer above the unified data model.
[0047] Example 3: While Example 2 addressed issues of experience solidification, domain expert involvement, and naming conflicts, it still revealed unresolved technical problems: functional modules and engineering data lacked a hierarchical foundation, hindering cross-project reuse; parameter attribute changes could not be automatically linked, requiring manual synchronization at each location; and the introduction of new heterogeneous data processing systems necessitated refactoring of the interface logic. This example further addresses the technical problems not covered by Example 2: it provides a unified foundation for engineering data through a three-tiered database architecture (platform framework database, current project database, and functional database), decoupling functional modules from specific project orchestrations and enabling cross-project reuse; it achieves dynamic attribute expansion through key-value extension tables and uses an event bus for publish-subscribe linkage recalculation, automatically propagating changes from one point to all relevant modules; and it reduces the expansion cost of new systems from "each refactoring" to "writing an interface for access" through plug-and-play access (establishing a unified access interface and declaring modules and dependencies for inclusion in scheduling). Compared to Example 2, this example provides a sustainably expandable system foundation and automatic linkage capabilities, supporting long-term accumulation through low-code crowdfunding.
[0048] Three-tier database architecture data foundation and module embedding Define the inclusion relationship between functional modules and basic functions, clarify the logical relationships between modules, and populate module data into a three-level database architecture: platform framework database (providing a shared framework), current project database (integrating current project data), and functional database (containing data from each functional module). The three-level database architecture provides a unified foundation for project data, breaks down data silos between modules, and decouples functional modules from specific project orchestration, making them reusable.
[0049] The advantages of this approach are: the platform framework, current project, and functional modules are organized hierarchically, allowing modules to be reused in different projects, and eliminating the need to build new projects from scratch. Those skilled in the art, when integrating multi-source project data, typically use a single database or simple database partitioning by project, rarely considering separating the platform framework database, current project database, and functional database into three levels, and using module inclusion and logical relationships to decouple functional modules from project orchestration, thereby supporting low-code, crowdfunding-style continuous accumulation.
[0050] Dynamic attribute expansion and change linkage The unified data model supports dynamic attribute expansion via key-value extension tables—when a parameter needs a new attribute field added, the extension can be registered without modifying the underlying structure. When any data item attribute changes, the change is pushed to all modules subscribed to that data item via an event bus using a publish-subscribe approach, triggering a recalculation or prompt for related parameters. The three-tier database architecture follows a pre-defined data flow protocol and ensures data consistency through two-phase commit. Thus, an attribute change can automatically propagate to all relevant modules, avoiding omissions during manual synchronization.
[0051] The advantages of this approach are: a change in one attribute automatically propagates to all relevant modules, ensuring data consistency across systems without requiring manual modifications. Those skilled in the art, when extending parameter attributes, typically modify the underlying data structure or manually notify relevant modules. It's difficult to conceive of using key-value extension tables to achieve dynamic expansion without structural changes, and then using an event bus publish-subscribe mechanism to automatically link changes to subscribed modules, combined with a two-phase commit mechanism across the three-tier database architecture to guarantee consistency.
[0052] Plug and play access to new heterogeneous data processing systems When adding a new heterogeneous data processing system (such as the finite element analysis system ABAQUS), it is only necessary to establish a corresponding unified parameter access interface for it and declare its functional modules and parameter dependencies. This allows the system to be included in the scheduling scope of the unified parameter access interface without needing to write separate interface logic or refactor the existing data chain. This access is completed by domain experts through configuration, without the need for program development. Therefore, the system expansion cost is reduced from "refactoring and connecting every time" to "writing an interface and declaring it for access," and it supports domain experts in continuously extending the application layer using pseudo-programming.
[0053] The advantages of this approach are: system expansion no longer requires writing dedicated interface code for new systems or reconstructing existing data chains, significantly reducing expansion cycles and costs. When introducing new heterogeneous data processing systems (such as finite element analysis systems), those skilled in the art typically treat them as independent tools to be individually interfaced with or have existing interfaces reconstructed. They rarely consider that by simply establishing a unified parameter access interface and declaring modules and dependencies, the system can be seamlessly integrated into the existing dependency-driven scheduling and dynamic backtracking system, allowing domain experts to complete the integration through configuration rather than programming.
[0054] System and Media Examples Corresponding to the methods described in Embodiments 1 to 3 above, the present invention also provides a heterogeneous design data processing system based on parameter dependencies. This system includes: a data model module for performing the aforementioned unified data model establishment and configuring attribute metadata and assigning globally unique identifiers to each parameter; a unified parameter access module for performing the aforementioned unified parameter access interface establishment; a format standardization module for performing the aforementioned parameter exchange format specification; a dependency graph derivation and scheduling module for performing the aforementioned directed acyclic graph construction, dependency-driven scheduling, and dynamic backtracking; an execution module for performing the aforementioned computational task delivery and result write-back; a data flow record module for the aforementioned data flow record and traceability; and a platform and user interface module for providing a visual display of module selection, parameter input, dependency configuration, execution status, and data flow links. Its collaborative working method is as described in Embodiments 1 to 3, and will not be repeated here.
[0055] The present invention also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of the aforementioned method; the storage medium may be any one or more combinations of read-only memory, random access memory, disk, optical disk, solid-state drive, etc.
[0056] Those skilled in the art will understand that each functional module of the above system can be implemented by software, hardware or a combination thereof, and its execution actions correspond one-to-one with the aforementioned method embodiments. Therefore, all the descriptions in Embodiments 1 to 3 can be used as specific implementations of the system claims and the medium claims, and the two share the same technical concept and technical effect.
Claims
1. A method for processing heterogeneous design data based on parameter dependencies, characterized in that, Includes the following steps: S1. Establish a unified data model for engineering design parameters, configure attribute metadata for each parameter including identifier, name, data type, level, ownership, source, destination and association, and assign a globally unique identifier to each parameter based on a unified naming rule; S2. Based on the unified data model, establish a unified parameter access interface across multiple heterogeneous data processing systems; S3. Specify a parameter exchange format that is independent of the heterogeneous data processing system; S4. Construct a directed acyclic graph based on the input-output dependencies between parameters, with functional modules as nodes and parameter flow directions as edges, and bind corresponding data processing logic to each node; according to the topological order of the directed acyclic graph, trigger the execution of the node when the output parameters of the predecessor node meet the constraints, and backtrack along the dependencies and re-execute the affected node when the node output does not meet the preset specifications. S5. The computing tasks of each node are sent to the heterogeneous data processing system that carries the corresponding data processing logic for execution, and the execution results are written back to the unified data model. S6. During each cross-system parameter transfer, record the data source system, target system, transfer timestamp, data change content, parameter unique identifier and transfer type, and generate a data transfer record.
2. The heterogeneous design data processing method according to claim 1, characterized in that, S2 specifically refers to: For each type of heterogeneous data processing system, a corresponding unified parameter access interface is established, which encapsulates the parameter format conversion, calling, and result parsing for that type of system. When a new type of heterogeneous data processing system is added, a corresponding unified parameter access interface is established and its functional modules and parameter dependencies are declared, and it is included in the scheduling scope of the unified parameter access interface.
3. The heterogeneous design data processing method according to claim 1, characterized in that, The dynamic backtracking described in S4 specifically includes: When the output parameters of a node do not meet the preset specification requirements, the set of all affected downstream nodes is determined along the reverse path of the dependency relationship in the directed acyclic graph. Adjust the input parameters or calculation conditions of the upstream node; Re-execute the upstream node and all its downstream nodes according to the directed acyclic graph; The resulting data from the re-execution is written back to the unified data model, triggering the recalculation of associated parameters in its downstream nodes until the output parameters of all nodes meet the specification requirements.
4. The heterogeneous design data processing method according to claim 1, characterized in that, S6 specifically refers to: Each time data flows across heterogeneous data processing systems, record the data source system, target system, flow timestamp, data change content, unique identifier of the flowed parameter, and flow type. Construct a visualized data flow chain based on the recorded information; In response to a request to trace any final output parameter, the data flow is traced backward node by node to determine the original data source and the path of each flow for that output parameter.
5. The heterogeneous design data processing method according to claim 1, characterized in that, The directed acyclic graph described in S4 uses functional modules as nodes and parameter flow directions as directed edges; the activation condition of any node is that the output parameters of all its predecessor nodes satisfy the constraint conditions; the data processing logic is bound to the data nodes and is used to generate the output parameters corresponding to that node.
6. The heterogeneous design data processing method according to claim 1, characterized in that, The parameter exchange format described in S3, which is independent of heterogeneous data processing systems, is based on the attribute metadata definition of the unified data model and supports bidirectional reading and writing of parameters between heterogeneous data processing systems.
7. The heterogeneous design data processing method according to claim 1, characterized in that, It also includes the module embedding step: Define the inclusion relationship between functional modules and basic functions, and clarify the logical relationships between modules; The module data is filled into a three-level database architecture, which includes a platform framework database, a current project database, and a functional database, respectively used to provide a shared framework, integrate current project data, and collect data from various functional modules.
8. The heterogeneous design data processing method according to claim 1, characterized in that, The data processing logic described in S4 includes two categories: normative derivation logic and experience-based logic. The experience solidification logic is a reserved data processing logic binding interface for experience-based data items; For empirical data that cannot be directly calculated from engineering specifications or formulas, it can be solidified and registered as reusable data processing logic through the macro or programming functions of the table processing system, and bound to the binding interface for nodes of the directed acyclic graph to call; engineering designers can complete the solidification of the empirical data module without writing program code.
9. The heterogeneous design data processing method according to claim 1, characterized in that, It also includes a naming conflict detection step: Perform conflict detection on data item names originating from different functional modules or different heterogeneous data processing systems; A three-level progressive conflict detection method is adopted: First, an exact match detection is performed to determine whether the names of two data items are completely identical; if no match is found, a thesaurus is queried for semantic equivalence detection; if no match is found again, the edit distance similarity between the two data item names is calculated, and if it exceeds a preset threshold, it is determined to be a conflict; the detected naming conflict is blocked, and a global reference index table is maintained to notify all modules that reference the data when any data name is changed.
10. The heterogeneous design data processing method according to claim 1, characterized in that, It also includes the steps for dynamic attribute expansion and change linkage: The unified data model supports dynamic attribute expansion via key-value expansion tables; When any data item attribute changes, the change is pushed to all modules that have subscribed to that data item via the event bus in a publish-subscribe manner, triggering the recalculation or prompt of related parameters; The three-tier database architecture follows a preset data flow protocol between databases at each level and ensures data consistency through two-phase commit.
11. The heterogeneous design data processing method according to claim 1, characterized in that, The construction of the functional modules is completed by the engineering designers through the following configuration operations, without writing any program code: declaring the parameter dependencies between the functional modules; Bind the corresponding data processing logic to the data nodes; Configure data links within and between modules.
12. A heterogeneous design data processing system based on parameter dependencies, characterized in that, To implement the method of claim 1, the method comprises: The data model module is used to perform the unified data model establishment described in claim 1, S1; A unified parameter access module is used to perform the establishment of the unified parameter access interface as described in S2 of claim 1; The format standardization module is used to execute the parameter exchange format specification of S3 as described in claim 1; the dependency graph derivation and scheduling module is used to execute the directed acyclic graph construction, dependency-driven scheduling and dynamic backtracking of S4 as described in claim 1. The execution module is used to perform the computation task delivery and result write-back as described in claim 1, S5; The data flow recording module is used to perform data flow recording and tracing as described in claim 1 (S6); the platform and user interface module is used to provide a visual display of module selection, parameter input, dependency configuration, execution status, and data flow chain.
13. A computer-readable storage medium, characterized in that, The storage medium stores computer program instructions, which, when executed by a processor, implement the heterogeneous design data processing method based on parameter dependencies as described in any one of claims 1 to 11.
