A heterogeneous CAE process data management method and system

By separating business logic data from plugin native data in the CAE simulation process and using a resolvable semantic schema for semantic negotiation, the problems of low data conversion efficiency and information loss in existing technologies are solved, enabling efficient management and flexible evolution of heterogeneous CAE processes.

CN123069773APending Publication Date: 2026-11-10粤港澳大湾区(广东)国创中心
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611320357.7
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-08-28
Publication Date
2026-11-10

AI Technical Summary

Technical Problem

Existing heterogeneous CAE tool integration solutions suffer from low data conversion efficiency, information loss, and difficulty in data reuse under tool replacement and environmental changes when facing open CAE integration platforms. Furthermore, they lack effective management and compatibility assessment of native data.

Method used

The business logic data and plugin native data in the CAE simulation process are constructed as independent data domains. The meaning and access method of the plugin native data are described by a parsable semantic schema. Semantic supply and demand negotiation and compatibility judgment are performed to generate a lightweight runtime semantic binding instance, enabling downstream nodes to access upstream native data on demand.

Benefits of technology

It decouples business logic from tools, supports data reuse and binding local updates under solver replacement, version upgrades and environment changes, and improves the data management efficiency and evolution flexibility of heterogeneous CAE processes.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123069773A_ABST
    Figure CN123069773A_ABST
Patent Text Reader

Abstract

This invention provides a heterogeneous CAE process data management method and system. The method includes: constructing business logic data and plugin native data into independent data domains and versioning them separately; describing the meaning, positioning rules, and parsing entry points of the plugin native data through a parsable semantic schema; performing semantic supply and demand negotiation and compatibility determination between upstream and downstream nodes; generating runtime binding instances containing native asset references and positioning expressions, enabling downstream access to native data on demand without constructing a unified intermediate object; simultaneously establishing three lineages: business logic, plugin native data, and runtime binding data; and achieving partial verification and failure control of bindings by comparing change signatures with binding dependency signatures. This invention decouples business logic from tool implementation, supports data reuse and partial binding updates under solver replacement, version upgrades, and environment changes, avoids full data conversion, and significantly improves the data management efficiency and evolutionary flexibility of heterogeneous CAE processes.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This invention relates to the field of computer-aided engineering technology, and in particular to a heterogeneous CAE process data management method and a heterogeneous CAE process data management system. Background Technology

[0002] CAE simulations typically require the collaboration of multiple heterogeneous software programs. A typical workflow may include CAD geometry import, geometry repair, mesh generation, material and physical property setting, boundary condition setting, solver execution, result extraction, post-processing visualization, and report generation. Different stages may utilize software such as FreeCAD, SALOME, Gmsh, HyperMesh, Abaqus, CalculiX, Nastran, OpenFOAM, ParaView, or in-house developed tools. Each software has different data formats, object models, version systems, script interfaces, operating methods, and hardware resource requirements.

[0003] Existing heterogeneous CAE tool integration solutions typically employ the following methods: 1. The upstream tool exports the file, and the downstream tool reads it according to a pre-agreed file format; 2. Develop a separate format conversion interface for each pair of upstream and downstream tools; 3. Define a unified intermediate data structure within the platform, including geometry, mesh, material, load, and solution results. Each plugin converts its own native data into the unified structure, and then other plugins convert the unified structure back into their own data. 4. Store business process parameters, plugin execution parameters, native file addresses, software versions, runtime logs, and hardware configurations in the same process node object; 5. Only record simple input-output relationships between files or process nodes to support result querying or historical tracing.

[0004] The above solution can achieve a certain degree of software connectivity, but it has significant limitations when dealing with open CAE integration platforms, frequent changes in underlying tools, integration with multiple software versions, and processing large-scale simulation results, as follows: First, the unified intermediate data model requires all plugins to fully parse and convert the raw data into platform-defined data objects. For large meshes, transient flow fields, nonlinear solution results, and multi-timestep field data, the complete conversion generates a large number of object construction, memory copying, serialization, and deserialization operations. The unified model may also fail to fully express the element properties, solution control parameters, contact definitions, integral point results, or proprietary data organization methods specific to a particular software, resulting in information loss.

[0005] Secondly, when business logic data and plugin native data are stored together, changing the solver, upgrading the software version, modifying the plugin interface, or adjusting the runtime environment will directly cause changes in the structure of business process objects. Conversely, changes in business goals or result indicators may also force the plugin data to be reorganized. The two types of data cannot evolve independently, making it difficult for the platform to achieve "replaceable underlying tools and stable upper-level processes".

[0006] Furthermore, existing plugin description files typically only record the plugin name, entry point, input format, and output format, lacking executable descriptions of information such as the internal location of the raw data, parsing method, available business semantics, required business semantics, software version, dependent libraries, operating system, container image, CPU / GPU configuration, parallelism method, and numerical precision. Even if upstream and downstream nodes know that a file exists, they cannot understand which data in the file meets their needs or how to access it.

[0007] Furthermore, traditional data lineage often only records "file A was generated by node B" or "node C uses file A," failing to distinguish between business process versions, plugin execution versions, and their binding relationship in a particular run. When software, plugins, parsers, or runtime environments change, it becomes difficult to determine whether existing data can still be correctly understood by the current process, and it is also difficult to re-establish compatibility relationships without modifying business data. Summary of the Invention

[0008] In view of the above problems, the present invention is proposed to provide a heterogeneous CAE process data management method and a corresponding heterogeneous CAE process data management system that overcomes or at least partially solves the above problems.

[0009] This invention discloses a heterogeneous CAE workflow data management method, the method comprising: The business logic data and plugin native data in the CAE simulation process are respectively constructed as independent business logic data domains and plugin native data domains. Load the semantic declaration of the capabilities that can be provided corresponding to the plugin, and perform compatibility negotiation between the semantic declaration of capability requirements generated by the business node and the semantic declaration of the capabilities that can be provided. Generate a runtime semantic binding instance for the semantic declarations that pass the compatibility negotiation; the runtime semantic binding instance includes at least a business semantic identifier, a native asset reference and the native data location expression. Based on the native asset reference and the native data location expression in the runtime semantic binding instance, access the plugin native data of the plugin native data domain.

[0010] Optionally, the business logic data and plugin native data in the CAE simulation process are constructed into independent business logic data domains and plugin native data domains, respectively, including: Receive simulation requirements or load process templates, establish a business logic diagram that does not depend on specific CAE software, configure business parameters, input semantics, output semantics and evaluation rules for each business node in the business logic diagram, and use the business logic diagram as the business logic data domain; Receive plugin registration requests, record plugin identifier, software identity and plugin version, and record the native input and output, tool version, plugin version, parser version, runtime environment and performance information generated during plugin execution into the plugin native data field; Establish independent version numbers and lifecycles for the business logic data domain and the plugin native data domain, respectively.

[0011] Optionally, load the semantic declaration of the capabilities that the plugin can provide, including: Perform syntax structure verification and version signature verification on the semantic declarations of the capabilities provided by the plugins; After successful verification, the software name, software version, plugin version, and parser version are extracted from the semantic declaration of the capabilities provided as tool identity information. The native asset types declared in the provided capability semantics declaration and their positioning rules within the native file are parsed, and the native data positioning expression is compiled. Establish a mapping index between the semantic identifier of the capability and the native data location expression.

[0012] Optionally, compatibility negotiation is performed between the capability requirement semantic declaration generated by the business node and the available capability semantic declaration, including: The capability requirement semantic identifier in the capability requirement semantic declaration is matched and determined with the available capability semantic identifier in the available capability semantic declaration; If the semantic identifier matches successfully, the physical constraint determination, version compatibility determination, and runtime environment availability determination are performed sequentially. Based on the passing results of each judgment, the native data access strategy is determined.

[0013] Optionally, based on the pass / fail results of each judgment, a native data access strategy is determined, including: If the downstream business node supports receiving the upstream native asset format and the operating environment is compatible, then the native data access strategy is determined to be the native pass-through strategy. If the downstream business node does not support receiving the upstream native asset format, and the native data location expression supports reading within a specified range, then the native data access strategy is determined to be an on-demand parsing strategy. If the required capability semantics are not directly stored in the native data, but are obtained through calculations using existing fields in the native data, then the native data access strategy is determined to be a local derivation strategy. If none of the above strategies are satisfied and only the data within the request scope needs to be format converted, then the native data access strategy is determined to be a local conversion strategy.

[0014] Optionally, generating runtime semantic binding instances for semantic declarations obtained through compatibility negotiation includes: Obtain the normalized hash value of the current execution environment as the environment fingerprint; The semantic identifiers corresponding to the capability requirement semantic identifiers and the available capability semantic identifiers that are successfully matched in the compatibility negotiation are used as the business semantic identifiers. The business semantic identifier, the native asset reference, the native data location expression, the parser identifier, the available capability semantic declaration version, and the environment fingerprint are encapsulated into a lightweight description object, which serves as the runtime semantic binding instance. Generate a binding dependency signature based on the business fields, capability semantic declaration fields, and environment fields that the runtime semantic binding instance depends on, and associate the binding dependency signature with the runtime semantic binding instance.

[0015] Optionally, based on the native asset reference in the runtime semantic binding instance and the native data location expression, accessing the plugin native data domain includes: When the native data access strategy is an on-demand parsing strategy, the corresponding parser is invoked according to the parser identifier recorded in the runtime semantic binding instance; The parser uses the native data location expression to locate the target dataset in the native file pointed to by the native asset reference; The data specified by the capability requirement semantic declaration is read either by streaming or by projecting from the target dataset.

[0016] Optionally, the method further includes: When a change is detected in the business logic data field or the plugin's native data field, a change signature is generated; The change signature is compared with the binding dependency signature of each runtime semantic binding instance to identify the target runtime semantic binding instance whose dependency field intersects with the change signature; Perform revalidation or renegotiation on the target runtime semantic binding instance, while keeping the data state of the unaffected runtime semantic binding instance and the other data domain unchanged.

[0017] Optionally, performing revalidation or renegotiation on the target runtime semantic binding instance includes: Check whether the modified capability semantics declaration provides the original business semantics, whether the native data location expression remains valid, and check whether the parser supports the current software version and operating environment. If the verification passes, update the version information in the target runtime semantic binding instance; If the verification fails, the target runtime semantic binding instance is determined to be invalid, and compatibility negotiation is re-executed based on the current plugin native data domain to generate a new runtime semantic binding instance.

[0018] This invention also discloses a heterogeneous CAE workflow data management system, the system comprising: The independent data domain construction module is used to construct the business logic data and plugin native data in the CAE simulation process into independent business logic data domains and plugin native data domains, respectively. The semantic negotiation and binding module is used to load the semantic declaration of the capabilities that the plugin can provide, and to perform compatibility negotiation between the semantic declaration of capability requirements generated by the business node and the semantic declaration of the capabilities that can be provided, and to generate a runtime semantic binding instance for the semantic declarations that pass the compatibility negotiation; the runtime semantic binding instance includes at least a business semantic identifier, a native asset reference and the native data location expression; The plugin native data access module is used to access the plugin native data in the plugin native data domain based on the native asset reference and the native data location expression in the runtime semantic binding instance.

[0019] This invention has the following advantages: This invention constructs business logic data and plugin native data into independent data domains and versions them separately. It describes the meaning, location rules, and parsing entry points of plugin native data through a parsable semantic schema, performing semantic supply and demand negotiation and compatibility determination between upstream and downstream nodes. This generates runtime binding instances containing native asset references and location expressions, allowing downstream access to native data on demand without constructing a unified intermediate object. Simultaneously, it establishes three lineages: business logic, plugin native data, and runtime binding, and achieves partial verification and failure control of bindings through comparison of change signatures and binding dependency signatures. This invention decouples business logic from tool implementation, supports data reuse and partial binding updates under solver replacement, version upgrades, and environment changes, avoids full data conversion, and significantly improves the data management efficiency and evolutionary flexibility of heterogeneous CAE processes. Attached Figure Description

[0020] Figure 1 This is a flowchart of a heterogeneous CAE workflow data management method provided in an embodiment of the present invention; Figure 2 This is a diagram of dual-domain data and binding relationships provided in an embodiment of the present invention; Figure 3 This is a flowchart of semantic negotiation and binding generation provided in an embodiment of the present invention; Figure 4 This is a dual-domain independent evolution and binding renegotiation diagram provided in an embodiment of the present invention; Figure 5 These are three types of bloodline diagrams provided in embodiments of the present invention; Figure 6 This is the Abaqus-ParaView on-demand binding sequence diagram of Example 1 provided in the embodiments of the present invention; Figure 7 This is a diagram showing the change in the two domains when the solver is replaced in Example 2 provided in this embodiment of the invention. Detailed Implementation

[0021] To make the above-mentioned objects, features and advantages of the present invention more apparent and understandable, the present invention will be further described in detail below with reference to the accompanying drawings and specific embodiments.

[0022] See Figure 1 This embodiment provides a heterogeneous CAE process data management method. This method constructs independent data domains for business logic data unrelated to specific software and native data generated by various CAE software plugins in the CAE simulation process. It describes the meaning and access methods of each plugin's native data using a resolvable semantic schema. Semantic supply and demand negotiation is performed between upstream and downstream business nodes to generate lightweight runtime semantic binding instances. This allows downstream nodes to directly reference or access upstream native data on demand without constructing a unified CAE intermediate data object. Simultaneously, it records business logic lineage, plugin native lineage, and runtime binding lineage separately, achieving mutual isolation between changes in business logic, plugins, software versions, and runtime environments. This invention is applicable to structural, fluid, thermal, acoustic, electromagnetic, and multiphysics CAE processes, as well as CAD, CAM, EDA, or other heterogeneous engineering software toolchains. Furthermore, it can be integrated with node fault diagnosis, partial re-execution, DOE batch computation, agent task planning, and HPC scheduling systems.

[0023] It should be noted that, referring to Figure 2 The business logic data domain and the plugin's native data domain are not directly mixed and stored; instead, they are connected through a lightweight runtime semantic binding instance. The runtime semantic binding instance mainly stores data references, positioning rules, and execution entry information, and does not copy the native grid, field data, or result data into the platform's unified structure.

[0024] The following section will detail the optional implementation methods for each of the above steps of the method: 1. Two-domain data construction This invention constructs the business logic data and plugin native data in the CAE simulation process into independent business logic data domains and plugin native data domains, respectively. Specifically, it includes the following steps: (1) Establishment of business logic data domain The system receives simulation requests or loads process templates, and establishes a business logic diagram independent of specific CAE software. The business logic diagram describes the business problem the simulation task aims to solve, including the set of business nodes, business dependencies, business parameters, node input semantics, node output semantics, evaluation rules, and business version. The business logic diagram does not store the native object structure of any specific CAE software and forms the basis for the stability of the upper-level process.

[0025] Specifically, each business node in the business logic diagram is configured with business parameters, input semantics, output semantics, and evaluation rules. Business parameters represent the business-level configuration information required for the node to execute the simulation task; input semantics represent the meaning of the data the node needs to receive at the business level, such as "volume mesh," "elastic material," and "displacement constraint," without specifying a particular software file format; output semantics represent the meaning of the data the node can provide at the business level, such as "displacement field" and "stress tensor"; and evaluation rules represent the standards and indicators for evaluating the node's output results at the business level. The configured business logic diagram serves as the business logic data domain.

[0026] Business version changes in the business logic data domain can include: changes in simulation targets, additions or deletions of business nodes, changes in parameters and evaluation metrics, changes in node semantic requirements, and changes in process dependencies. These changes are all adjustments at the business level and do not involve the native data structure of the specific software.

[0027] (2) Establishment of the plugin's native data domain Upon receiving a plugin registration request, the system records the plugin identifier, software identity, and plugin version. It also records the native input / output, tool version, plugin version, parser version, runtime environment, and performance information generated during plugin execution in the plugin's native data field. The plugin's native data field stores execution instance information for the specific software plugin without altering the structure of the business logic object.

[0028] A plugin execution instance stores factual information about a specific tool execution, including plugin identifier, software identifier, software version, plugin version, startup parameters, native input, native output, running status, and performance metrics. Plugin execution instances are not written to business logic objects, ensuring that the structure of business logic data fields is unaffected by the specific details of tool execution.

[0029] The plugin's native data domain also records a list of native assets. This list represents the native files, databases, memory objects, and remote objects generated by the plugin, including information such as asset identifier, native format, storage address, content hash, generated plugin instance, data size, availability, and lifecycle. Native assets can take various forms, including local files, shared files, object storage objects, database records, memory objects, remote object handles, streaming data sources, and simulation result services.

[0030] Version changes in the plugin's native data domain can include: software or patch version changes, plugin version changes, parser version changes, native file formats, object structure changes, startup parameter changes, and changes in runtime and hardware environments.

[0031] (3) Independent version number and lifecycle Independent version numbers and lifecycles are established for the business logic data domain and the plugin's native data domain. When either domain changes, the data content of the other domain is not directly modified. Instead, a comparison mechanism between the change signature and the binding dependency signature determines whether the affected binding relationship needs to be re-verified or renegotiated. This independent versioning mechanism ensures that the business process structure remains stable when the solver is changed, the software version is upgraded, the plugin interface is modified, or the runtime environment is adjusted. Conversely, when business goals or result indicators change, the plugin data is not forced to be reorganized.

[0032] 2. Loading and parsing of parsable semantic schema (1) Location and composition of parsable semantic schema A resolvable semantic schema describes how a plugin generates, stores, locates, and accesses its native data. A schema is a set of declaration and resolution rules oriented towards a specific tool, rather than a unified data model for all CAE software. Unlike a unified intermediate data model that dictates what unified object data from different software must ultimately be transformed into, the resolvable semantic schema in this invention specifies: where in which native data a particular business semantic exists, which resolution entry point, and under what access methods and environmental constraints it should be read. Therefore, different plugins can retain their own native data structures, only needing to provide a description that can be parsed by the schema interpreter.

[0033] A parsable semantic schema can be implemented using YAML, JSON, XML, Protocol Buffers description files, domain-specific languages, or database records, as long as it can express the tool's identity, semantic supply and demand, native data location, parsing entry point, environmental constraints, and failure rules. A parsable semantic schema should include at least the following field groups: ① Schema identity: includes schema identifier, schema version, namespace, and applicable plugins, used to uniquely identify and version manage the schema.

[0034] ② Tool identity: This includes software name, software version, patch version, plugin version, and parser version, used to clearly identify the toolchain information that generates and manages native data.

[0035] ③ Runtime environment: This includes the operating system, architecture, runtime, dependent libraries, container images, and license model, describing the software environment conditions required for the software to run.

[0036] ④ Hardware environment: This includes CPU instruction set, number of cores, GPU model, video memory, system memory, and parallel mode, describing the hardware resource requirements for software operation.

[0037] ⑤ Native Assets: Describes the type and form of native data generated by the plugin, which can be files, databases, memory objects, remote objects, object storage, or result services.

[0038] ⑥ Provide semantics: Describe the business semantics and constraints that the plugin's native data can provide. It is the basis for upstream nodes to declare their data capabilities to downstream nodes.

[0039] ⑦ Requirement semantics: Describes the business semantics required by the plugin when executing or consuming data, and is the basis for the plugin to declare its input requirements.

[0040] ⑧ Native localization: Describes the dataset, object attributes, path expressions, record types, time steps, regions, and component locations within the native file, used to accurately locate target information in the native data.

[0041] ⑨ Parsing entry point: Includes parser name, version, calling protocol, reading function, streaming interface, iterator entry point, specifying the specific execution method for accessing raw data.

[0042] ⑩ Access methods: including native passthrough, random read, block read, streaming read, on-demand projection, local derivation, and local transformation, describing the access modes that can be used for native data.

[0043] Compatibility rules include software version range, schema compatibility range, unit constraints, coordinate system constraints, precision constraints, and topological location constraints, which are used to determine compatibility between upstream and downstream components.

[0044] Derivation rules: describe the semantics, computation entry point, and preconditions that can be calculated from existing raw data.

[0045] Failure rules: Describe which changes to business fields, plugin fields, version fields, and environment fields will cause the binding to fail.

[0046] (2) Schema loading and validation When loading the semantic declaration of the capabilities provided by the plugin, the semantic declaration of the capabilities provided by the plugin is subjected to syntax structure validation and version signature verification. Syntax structure validation ensures that the schema file is in the correct format, the fields are complete and conform to the predefined description specifications; version signature verification ensures that the schema source is trustworthy and has not been tampered with.

[0047] After successful verification, the software name, software version, plugin version, and parser version are extracted from the semantic declaration of available capabilities to serve as tool identity information. This tool identity information uniquely identifies the toolchain that generates and manages native data and forms the basis for subsequent compatibility assessments and environment matching.

[0048] (3) Compilation of native data location expressions The parsing process provides access to native asset types declared in the capability semantics declaration and their location rules within the native files, compiling them into native data location expressions. These native data location expressions are used to precisely describe the specific location of a business semantic within the native data. They can be implemented using object paths, file record types, JSONPath, XPath, SQL, HDF5 dataset paths, regular expressions, script expressions, function entry points, or dedicated binary record location rules.

[0049] For example, for ODB format result files generated by the Abaqus solver, the native data location expression can be something like "steps[ The object path format "].frames[-1].fieldOutputs["S"]" indicates the location of the field output data named "S" in the last frame of all analysis steps. For FRD format result files generated by the CalculiX solver, the native data location expression can include a combination of information such as dataset name, time step identifier, and record layout.

[0050] (4) Establishment of mapping index Establish a mapping index between the semantic identifiers of the capabilities and the native data location expressions. This mapping index associates the semantic identifiers with the native assets, native locations, and resolution entry points, forming a complete index relationship of "business semantics—native assets—native locations—resolution entry points".

[0051] The schema parsing process also compiles access patterns into direct pass-through, random read, region read, time-step read, field projection, streaming read, and partial derivation operations, and generates a schema dependency summary for subsequent binding failure detection. It's important to emphasize that the schema parsing process only compiles descriptive information; it does not open or load the entire raw big data. Raw data is only read according to the access plan when downstream nodes actually request it.

[0052] Taking the Abaqus plugin schema as an example, its declaration includes: the tool identity is Abaqus 2024.HF3, the plugin version is 2.6.0, the parser is abaqus-odb-parser 2.1; the runtime environment is Windows Server 2022, the architecture is x86_64, and it depends on odbAccess 2024 and Python. 3.10; Hardware requirements: x86_64 architecture, minimum 8 cores, minimum 32GB memory; Native assets include input files in .inp format and result files in .odb format; Provided semantics include nodal displacement fields (location expression is steps[].frames[-1].fieldOutputs["U"], supporting random, projected, and streaming access, unit is mm, coordinate system is global coordinate system, location is node) and stress tensors (location expression is steps[].frames[-1].fieldOutputs["S"], supporting projected, region, and streaming access, unit is MPa, location is integration point); Required semantics include volume mesh, elastic material, and displacement boundary conditions; Failure rule declaration: When the tool version, parser version, ODB interface dependencies, or native location expressions providing semantics change, the relevant bindings should be marked as requiring revalidation.

[0053] Taking the Schema of the CalculiX plugin as an example, its declaration includes: the tool identity is CalculiX 2.22, the plugin version is 1.8.0, the parser is calculix-frd-parser 4.0; the native assets are result files in frd format; the semantics provided include structural stress tensors (dataset is STRESS, time step is LAST, record layout is FRD-2.3, supports sequential, regional and projection access, unit is MPa, location is node or integration point).

[0054] Abaqus and CalculiX schemas have different native location rules and parsing entry points, but both can declare that they can provide "structural stress tensor" semantics. The platform does not require both to generate a unified result object beforehand; instead, the schema interpreter compiles it into access plans for ODB or FRD respectively.

[0055] 3. Semantic negotiation and compatibility determination (1) Semantic supply and demand declaration Upstream nodes declare the semantic sets they can provide through the plugin schema:

[0056] Downstream business nodes generate capability requirement semantic declarations, i.e., requirement semantic sets:

[0057] Each requirement semantic includes at least a capability requirement semantic identifier and may include constraints such as units, coordinate system, data location, precision, time range, spatial range, and acceptable access methods. Requirement semantics do not include specific software file format requirements; they only describe, from a business perspective, what data downstream nodes actually need and the acceptable consumption methods.

[0058] (2) Compatibility negotiation process Reference Figure 3 The compatibility negotiation between the capability requirement semantic declaration generated by the business node and the available capability semantic declaration includes the following steps: First, the capability requirement semantic identifiers in the capability requirement semantic declaration are matched with the available capability semantic identifiers in the available capability semantic declaration. The matching criteria include: the upstream providing semantics is identical to the downstream requirement semantics; they belong to acceptable hierarchical semantics; and there is a derivation relationship in the schema declaration. Semantic compatibility can be achieved using rule matching, type reasoning, knowledge graph reasoning, or a combination of rules and machine learning models, but the final generated binding should include a clear original data location and an executable access plan.

[0059] If the semantic identifier matches successfully, the following checks will be performed sequentially: ① Physical constraint determination: Check whether the units, coordinate system, data location, component definitions, and accuracy meet the downstream requirements. For example, if the downstream requires the stress unit to be MPa and the data location to be a node, then it is necessary to verify whether the stress data provided by the upstream meets these physical constraints.

[0060] ② Version compatibility check: Check whether the software, plugins, schema, and parser are within the compatible version range. Version compatibility checks ensure that the currently used tool version can correctly generate and parse the relevant native data.

[0061] ③ Runtime Environment Availability Assessment: Check whether the runtime environment and dependencies required to parse native data are available. Runtime environment availability assessment includes verifying conditions such as operating system, dependency libraries, container images, and licenses.

[0062] In addition, compatibility negotiation can also include access capability determination (whether the access modes supported by the upstream match the consumption modes acceptable to the downstream), native asset validity determination (whether the asset exists, whether the hash matches, and whether the lifecycle is valid), and access cost determination (comparing the expected read volume, copy volume, and computation volume of direct transmission, partial resolution, partial derivation, and partial transformation). The access cost can be estimated based on asset size, expected number of bytes read, number of object constructions, number of memory copyings, network transmission volume, transformation time, and historical operation statistics.

[0063] (3) Determining the native data access strategy Based on the pass / fail results of each judgment, the native data access strategy is determined. Based on the judgment results, candidate bindings are divided into the following levels: ① Native Pass-Through Strategy (Level A): If downstream business nodes support receiving upstream native asset formats and their operating environments are compatible, then the native data access strategy is determined to be the native pass-through strategy. Conditions for native pass-through include: downstream tools natively support the upstream output format; upstream and downstream belong to the same software ecosystem and can share native databases or objects; downstream plugins can receive file addresses, object storage addresses, remote service addresses, and native object handles; downstream plugins declare that they accept the format, version, and access protocol of the native asset. During native data pass-through, the bound instance directly saves the native asset reference and access credentials, without reading the native asset content.

[0064] ② On-Demand Parsing Strategy (Level B): If downstream business nodes do not support receiving upstream native asset formats, and the native data location expression supports reading within a specified range, then the native data access strategy is determined to be an on-demand parsing strategy. On-demand parsing conditions may include: specifying a time step or frame, specifying a geometric region, node set, cell set or boundary, specifying a physical quantity, specifying a tensor or vector component, specifying a data location, and specifying precision or sampling rate. The parser performs random reading, block reading, memory mapping, streaming reading, and iterative reading according to the access plan, without constructing a unified object containing all results.

[0065] ③ Local Derivation Strategy (Level C): If the required capability semantics are not directly stored in the native data and are calculated using existing fields in the native data, then the native data access strategy is determined to be a local derivation strategy. Typical scenarios for local derivation include: locally calculating von Mises stress from the stress tensor; locally calculating displacement amplitude from the displacement vector; locally calculating peak values ​​or envelopes from multiple time steps; and locally interpolating node data to a specified sampling point. The local derivation result is only generated for the scope of downstream requests and is recorded as a derived asset record in the plugin's native data domain, not written to the business logic object.

[0066] ④ Partial Transformation Strategy (Level D): If none of the above strategies are satisfied and only data within the request scope needs to be format-converted, then the native data access strategy is determined to be the partial transformation strategy. Partial transformation follows these principles: only the physical quantities of downstream requests are transformed; only the temporal and spatial ranges of requests are transformed; native assets are retained as the source of facts; the converter version, input hash, and output hash are recorded; the transformation result is registered as a plugin native domain derived asset; and this partial transformation is written into the runtime binding lineage.

[0067] ⑤ Incompatibility (Level E): When the current tool, version, environment, or data cannot meet the downstream requirements, it is judged as incompatible, and a new plugin needs to be selected.

[0068] ⑥ The system prioritizes binding methods with higher levels and lower data materialization costs.

[0069] 4. Generation of runtime semantic binding instances For semantic declarations obtained through compatibility negotiation, runtime semantic binding instances are generated:

[0070] in: Indicates the business node and version; Indicates a business semantic request; Indicates a plugin execution instance; Indicates the original asset; Indicates the schema and version; Indicates the parser and version; Indicates the execution environment fingerprint; Indicates the native data access plan; This indicates the binding dependency signature.

[0071] Specifically, the following steps are included: (1) Acquisition of environmental fingerprints The normalized hash value of the current execution environment is obtained as the environment fingerprint. The environment fingerprint includes: software name, major version, minor version, and patch version; plugin version, schema version, and parser version; operating system and architecture; container image identifier and image digest; Python, Java, C / C++ runtime library and critical dependency library versions; CPU architecture, instruction set, and number of cores; GPU model, driver, and computing power; memory and video memory capacity; solver parallel mode, number of processes, and number of threads; single-precision or double-precision mode; license mode; and region, language, and character encoding settings related to native data parsing. The system normalizes and sorts these fields and calculates their hashes to form the environment fingerprint.

[0072] The environment fingerprint encompasses multiple dimensions, including software, plugins, parsers, operating systems, dependency libraries, CPU / GPU configurations, and parallel processing. Changes in environment fields do not directly modify business logic data; instead, they are assessed based on the binding dependency signature to determine whether they affect native data generation, native data parsing, downstream consumption, result reproduction, and performance comparison. For example, changes in the number of CPU cores may affect performance lineage but not result semantic binding; changes in the ODB interface version may directly affect parsing binding. The system distinguishes between these two types of changes through the binding dependency signature.

[0073] (2) Determination of business semantic identifiers The semantic identifiers corresponding to the capability requirement semantic identifiers that are successfully matched during compatibility negotiation and the semantic identifiers of the available capabilities are used as business semantic identifiers. Business semantic identifiers can be implemented using hierarchical URIs, namespaces, knowledge graph concept identifiers, domain thesaurus identifiers, or enterprise-defined codes.

[0074] (3) Encapsulation of lightweight description objects Business semantic identifiers, native asset references, native data location expressions, parser identifiers, available capability semantic declaration versions, and environment fingerprints are encapsulated into lightweight description objects, serving as runtime semantic binding instances. These runtime semantic binding instances do not contain complete meshes, result arrays, or generic CAE objects; they only contain the references and rules required for access. Runtime bindings can be pre-generated during the process orchestration phase or dynamically generated based on the actual native assets after node execution.

[0075] Runtime semantic binding instances can also include native data access plans. A native data access plan compiles the schema into executable native data access steps, including native asset references, location expressions, parsers, filtering conditions, projection fields, access methods, and caching strategies. The native data access plan is also a lightweight description object, storing only data references, location rules, and execution entry points; it does not copy native mesh, field data, or result data into the platform's unified structure.

[0076] (4) Generation of binding dependency signatures A binding dependency signature is generated based on the business fields, capability semantic declaration fields, and environment fields that the runtime semantic binding instance depends on, and then associated with the binding dependency signature. The binding dependency signature includes the business fields, schema fields, software version range, resolver version, environment fields, and native asset hashes that the binding depends on. The binding dependency signature is used to determine which bindings need to be invalidated or revalidated when changes occur. Binding invalidation can be implemented using field dependency sets, dependency graphs, regular expressions, version ranges, and content hash comparisons.

[0077] 5. Access to raw data Based on the native asset references and native data location expressions in the runtime semantic binding instance, access the plugin's native data domain. The specific access method varies depending on the determined native data access strategy: (1) Native pass-through access When the native data access strategy is the native pass-through strategy, downstream nodes directly obtain native asset references and access credentials without reading the native asset content. Downstream tools directly access upstream native data through file addresses, object storage addresses, remote service addresses, and native object handles.

[0078] (2) On-demand parsing access When the native data access strategy is an on-demand parsing strategy, the corresponding parser is invoked based on the parser identifier recorded in the runtime semantic binding instance. The parser uses native data location expressions to locate the target dataset in the native file pointed to by the native asset reference. Data specified in the semantic declaration of the capability requirement is then read from the target dataset via streaming or projection.

[0079] The parser can be implemented using in-process dynamic libraries, standalone processes, Python scripts, container services, remote microservices, command-line tools, or the software's own scripting interface. The parser performs random reads, block reads, memory-mapped reads, streaming reads, and iterative reads based on the access plan, without constructing a unified object containing all results.

[0080] On-demand parsing supports precise reading by time step, region, physical quantity, and component. For example, it allows reading only data from a large result file at a specified time step, a specified geometric region, a specified physical quantity, and a specified tensor component, without loading the entire result file.

[0081] (3) Local Derivative Access When the native data access strategy is a partial derivation strategy, the parser first reads the required raw field data according to the native data location expression. Then, based on the derivation rules declared in the schema, it performs partial calculations on the read data to obtain the derived semantic data required by the downstream. The partial derivation result is generated only for the scope of the downstream request and serves as the derived asset record in the plugin's native data domain.

[0082] (4) Local conversion access When the native data access strategy is a partial transformation strategy, format conversion is only performed on data within the actual downstream request scope. The transformation process retains the native asset as the source of fact, records the converter version, input hash, and output hash, registers the transformation result as a plugin native domain derived asset, and writes this partial transformation into the runtime binding lineage.

[0083] 6. Independent Evolution of Dual-Domain Data and Binding Failure Control (1) Change detection and change signature generation When a change is detected in the business logic data domain or the plugin's native data domain, a change signature is generated. The change signature records the specific fields and changes involved in this change. Business logic version changes may include changes in simulation targets, additions or deletions of business nodes, changes in parameters, evaluation metrics, changes in node semantic requirements, and changes in process dependencies. Plugin native version changes may include changes in software or patch versions, plugin versions, parser versions, native file formats or object structures, startup parameters, and changes in the runtime or hardware environment.

[0084] (2) Identification of affected bindings The change signature is compared with the binding dependency signature of each runtime semantic binding instance to identify the target runtime semantic binding instance whose dependency field intersects with the change signature.

[0085] Let the signature of a certain change be Δ, and the set of dependent fields of the bound instance β be Dep(β).

[0086] when: In this case, the change will not affect the binding, and the binding will remain valid.

[0087] when: At that time, the system will only perform re-validation on the binding.

[0088] (3) Re-verify or renegotiate Reference Figure 4 This involves revalidating or renegotiating the target runtime semantic binding instance while maintaining the data state of unaffected runtime semantic binding instances and the other data domain. Revalidation specifically includes: ① Check whether the revised capability semantics declaration provides the original business semantics; ② Check if the original data location expression remains valid; ③ Check if the parser supports the current software version and operating environment; ④ Check whether the dependencies in the environment fingerprint are satisfied; ⑤ Check if the acceptable access patterns of downstream nodes have changed; ⑥ Check the native asset hash and lifecycle status.

[0089] If verification passes, the version information in the target runtime semantic binding instance is updated. If verification fails, the target runtime semantic binding instance is determined to be invalid, and compatibility negotiation is re-executed based on the current plugin native data domain to generate a new runtime semantic binding instance. The renegotiation process does not modify business logic data or refactor all plugin data.

[0090] (4) Typical change handling The following are typical handling methods for change scenarios: When Abaqus is replaced by CalculiX: the business logic data remains unchanged, the plugin native data domain generates a new plugin execution instance and FRD native assets, and the original business semantics are renegotiated and a new binding is established.

[0091] When upgrading from Abaqus 2023 to 2024: business logic data remains unchanged, plugin native data domain updates software, plugin, parser and environment information, and only verifies the binding of dependent software versions and ODB location rules.

[0092] When the number of CPU cores or parallel mode changes: business logic data remains unchanged, the plugin's native data field records the new execution environment and performance data, and the binding can remain effective when the semantics of result reading are not affected. Reproducible queries use the new environment fingerprint.

[0093] When the required outcome changes from the maximum stress to the top three dangerous areas: the business logic data domain updates the business semantic requirements, the existing native data remains unchanged, and it is determined whether the native result is sufficient. If it is sufficient, a new local derived binding is added; otherwise, a re-solution is required.

[0094] When the post-processing plugin is upgraded: the business process remains unchanged, the plugin's native data domain updates the downstream plugin's consumption capabilities, re-verifies its acceptable access mode, and does not re-transform all upstream data.

[0095] 7. Three types of bloodline records Reference Figure 5 This invention establishes three types of lineage relationships, rather than representing the entire lineage as a single file chain. These three types of lineage relationships can be implemented using relational databases, graph databases, document databases, event logs, or hybrid storage.

[0096] (1) Business Logic Lineage Business logic lineage record: business tasks and versions, business nodes and versions, business dependencies between nodes, business parameters and their sources, node requirement semantics and supply semantics, result evaluation metrics, business templates and business rule versions. The business logic lineage answers what business problem a particular simulation solves and how the business process evolves.

[0097] (2) Plugin native lineage Plugin lineage records include: software, software version and patches, plugins and plugin versions, parsers and parser versions, plugin execution instances, native inputs, native outputs and content hashes, startup commands and execution parameters, runtime and hardware environments, execution time, peak memory usage, performance metrics such as parallelism scale, and the generation and derivation relationships between native assets. Plugin lineage answers the question of which software, plugin, version, and environment generated a given set of data.

[0098] (3) Runtime binding of bloodline Runtime binding lineage records include: business node version, business semantic request, upstream plugin instance, native assets, native data location, schema and parser versions, environment fingerprint, access plan, binding level, binding generation time, verification status, and failure reason. Runtime binding lineage answers the question of which specific native data, through which rules and environment, interprets a particular business semantic in a given execution.

[0099] (4) Relationship query of three types of bloodline When a user queries a business result, the system first determines the corresponding business semantics of the result in the business logic lineage. Then, it locates the specific plugin instance, native asset, schema, resolver, and environment fingerprint through runtime binding lineage. Finally, it obtains the tool execution facts and establishes relationships with the native data in the plugin's native lineage. This query process does not require writing the plugin's native data into the business logic graph, nor does it require business logic objects to store software-specific fields.

[0100] The following are application examples of the method of the present invention in specific scenarios: Example 1: On-demand semantic binding of Abaqus solution results to ParaView post-processing Reference Figure 6 Users can establish a business process for structural component strength analysis, which includes geometric preparation, mesh generation, material assignment, load constraints, structural static solution, stress result extraction, and cloud map display nodes.

[0101] The "Structural Static Solver" node in the business layer only declares that: a volume mesh is required; an elastic material is required; displacement constraints and external loads are required; and displacement field and stress tensor results are provided. The business layer does not include Abaqus INP cards, ODB object paths, or FieldOutput object definitions.

[0102] The platform selects the Abaqus 2024.HF3 solver plugin in the current environment. After the plugin is executed, it generates job.odb and forms a native execution instance of the plugin, recording: software is Abaqus 2024.HF3; plugin version is 2.6.0; parser is abaqus-odb-parser 2.1; operating system is Windows Server 2022; CPU is 32 cores; parallel mode is domain; numerical precision is double; native asset is job.odb; as well as asset hash and data size.

[0103] The ParaView post-processing business node makes the following business semantic requests: the required semantic is structural stress tensor; the time range is the last frame; the region is all; the components are S11, S22, S33, S12, S13, and S23; the acceptable data location is a node or integration point; the acceptable unit is Pa or MPa; and the acceptable access mode is streaming, projection, or region reading.

[0104] The schema interpreter reads the Abaqus plugin schema and determines that the required stress tensor is located in job.odb; its native location is steps[ ].frames[-1].fieldOutputs["S"]; can be read by region and component using abaqus-odb-parser 2.1; the current ODB interface version is compatible with the parsing environment.

[0105] The system generates B-level "on-demand parsing" bindings instead of converting the complete ODB into a unified result object. Binding instance records: business semantics are structural stress tensors; native asset is job.odb; native location is the S field in the last frame of the last analysis step; parser version; schema version; environment fingerprint; access strategy is component-based streaming; consumer node is the ParaView post-processing plugin.

[0106] When a user only views von Mises stress, the system does not read the entire stress history and all result fields, but only reads the tensor components required in the last frame, and calculates the von Mises stress locally during the reading process. If the user subsequently views the displacement contour plot, the system generates a new on-demand binding based on another semantic provided by the same ODB, without modifying the business process nodes or re-converting the ODB.

[0107] This example avoids full ODB parsing, uniform result object construction, and secondary data copying, while retaining the ODB as a source of facts.

[0108] Example 2: Replace CalculiX with Abaqus while keeping the business process data unchanged. The platform already has a structural static analysis workflow, whose business nodes and semantic relationships are as follows: geometry preparation → mesh generation → materials and boundary conditions → structural static solution → displacement and stress result extraction → report generation.

[0109] The initial execution uses CalculiX 2.22. The CalculiX plugin schema declares that it requires mesh, material, and boundary condition semantics, and provides displacement and stress semantics through the native FRD assets. The platform establishes on-demand parsing bindings for the CalculiX FRD for post-processing nodes.

[0110] Reference Figure 7 Because users require specific nonlinear capabilities from Abaqus, the platform has replaced the candidate plugin for solving nodes from CalculiX with Abaqus. During the replacement process: (1) The business logic diagram, business node identifiers, business parameters, and result evaluation indicators remain unchanged; (2) The original CalculiX plugin execution instance and FRD assets are still retained in the plugin's native data domain; (3) Added Abaqus plugin execution instances and ODB native assets; (4) The platform reads the Abaqus Schema and determines that it also provides the displacement and stress semantics required for the business; (5) Regenerate ODB-oriented bindings for existing post-processing service nodes; (6) The original FRD binding is retained as a historical binding, and the new ODB binding becomes the current valid binding; (7) The reporting node continues to use the business semantics of "maximum displacement" and "maximum stress" without being aware that the results come from FRD or ODB.

[0111] In this example, the CalculiX data structure was not converted to an Abaqus data structure, nor were the business process objects modified. The changes to the underlying solver only caused changes to the plugin's native domain and binding lineage, demonstrating the independent evolution of business logic data and plugin data.

[0112] Example 3: Binding partial validation under Abaqus version upgrade and runtime environment changes A certain business process originally used Abaqus 2023, and its ODB was read by abaqus-odb-parser 1.8. The binding dependency signature recorded by the platform includes: software main version, ODB interface version, parser version, FieldOutput positioning expression, Python runtime environment, and the unit and position of the result field.

[0113] The server was subsequently upgraded to Abaqus 2024.HF3, and the runtime environment was changed from Python 3.9 to Python 3.10. The environment detection process generates a new environment fingerprint and produces the following change signatures: tool.version, runtime.dependencies.odbAccess, runtime.dependencies.python, and tool.parserVersion.

[0114] The system compares the change signature with the existing binding dependency signatures, and only selects ODB parsing bindings that depend on the above fields for verification. No modifications are performed on business parameters, geometric assets, mesh assets, and report templates that do not depend on the ODB interface.

[0115] The verification process confirmed that the old parser did not support the Abaqus 2024 ODB interface, therefore the original bindings became invalid. The system loaded the new parser and schema, recompiled the native positioning expressions, and generated new bindings. The business logic still references the same "displacement field" and "stress tensor" semantics, and the business logic version remains unchanged.

[0116] If only the number of CPU cores increases from 16 to 32, while the result fields and ODB interface remain unchanged, the environment change will only be written into the plugin execution performance lineage and will not cause the result parsing binding to fail.

[0117] This example illustrates that the system can distinguish between environmental changes that affect data interpretation and those that only affect execution performance, thus avoiding the need to rebuild all business and data relationships due to changes in any environmental field.

[0118] Example 4: Reusing existing native results due to expanded business outcome requirements A simulation has generated an Abaqus ODB, and the original business requirements only included: maximum von Mises stress and maximum displacement.

[0119] Subsequent users expanded their business requirements to include: maximum von Mises stress; the top three hazardous areas; the average stress in the specified hole edge area; and the stress peak envelope of the last five increments.

[0120] The business logic data domain adds corresponding evaluation semantics, but the existing ODB native assets remain unchanged. The platform checks according to the Abaqus Schema: the ODB contains stress tensors and region identifiers; the parser supports region filtering; the parser supports reading specified frame ranges; the schema declaration states that von Mises stress and peak envelope can be derived from the stress tensor.

[0121] The platform generates region filtering, last five-frame reading, and local derivation binding separately, accessing only the required regions and time ranges. If the ODB already contains sufficient data, there is no need to re-execute the solver; only if the original solver task does not output the required frame or region data will the system determine that the native asset cannot meet the new requirements and request a re-solve.

[0122] In this example, changes in business requirements only cause changes in business lineage and new bindings, without requiring migration or overall conversion of existing native data.

[0123] It should be noted that, for the sake of simplicity, the method embodiments are all described as a series of actions. However, those skilled in the art should understand that the embodiments of the present invention are not limited to the described order of actions, because according to the embodiments of the present invention, some steps can be performed in other orders or simultaneously. Furthermore, those skilled in the art should also understand that the embodiments described in the specification are preferred embodiments, and the actions involved are not necessarily essential to the embodiments of the present invention.

[0124] The heterogeneous CAE workflow data management system provided in this embodiment of the invention may specifically include: The independent data domain construction module is used to construct the business logic data and plugin native data in the CAE simulation process into independent business logic data domains and plugin native data domains, respectively. The semantic negotiation and binding module is used to load the semantic declaration of the capabilities that the plugin can provide, and to perform compatibility negotiation between the semantic declaration of capability requirements generated by the business node and the semantic declaration of the capabilities that can be provided, and to generate a runtime semantic binding instance for the semantic declarations that pass the compatibility negotiation; the runtime semantic binding instance includes at least a business semantic identifier, a native asset reference and the native data location expression; The plugin native data access module is used to access the plugin native data in the plugin native data domain based on the native asset reference and the native data location expression in the runtime semantic binding instance.

[0125] As the system implementation is basically similar to the method implementation, it is described in a relatively simple way. For relevant details, please refer to the description of the method implementation.

[0126] It should be noted that, in this document, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0127] The various embodiments in this specification are described in a related manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, the system embodiments are basically similar to the method embodiments, so the description is relatively simple; relevant parts can be referred to the descriptions of the method embodiments.

[0128] The above description is merely a preferred embodiment of the present invention and is not intended to limit the scope of protection of the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention are included within the scope of protection of the present invention.

Claims

1. A heterogeneous CAE workflow data management method, characterized in that, The method includes: The business logic data and plugin native data in the CAE simulation process are respectively constructed as independent business logic data domains and plugin native data domains. Load the semantic declaration of the capabilities that can be provided corresponding to the plugin, and perform compatibility negotiation between the semantic declaration of capability requirements generated by the business node and the semantic declaration of the capabilities that can be provided. Generate a runtime semantic binding instance for the semantic declarations that pass the compatibility negotiation; the runtime semantic binding instance includes at least a business semantic identifier, a native asset reference and the native data location expression. Based on the native asset reference and the native data location expression in the runtime semantic binding instance, access the plugin native data of the plugin native data domain.

2. The method according to claim 1, characterized in that, The business logic data and plugin native data in the CAE simulation process are constructed into independent business logic data domains and plugin native data domains, respectively, including: Receive simulation requirements or load process templates, establish a business logic diagram that does not depend on specific CAE software, configure business parameters, input semantics, output semantics and evaluation rules for each business node in the business logic diagram, and use the business logic diagram as the business logic data domain; Receive plugin registration requests, record plugin identifier, software identity and plugin version, and record the native input and output, tool version, plugin version, parser version, runtime environment and performance information generated during plugin execution into the plugin native data field; Establish independent version numbers and lifecycles for the business logic data domain and the plugin native data domain, respectively.

3. The method according to claim 2, characterized in that, Load the semantic declaration of the capabilities that the plugin can provide, including: Perform syntax structure verification and version signature verification on the semantic declarations of the capabilities provided by the plugins; After successful verification, the software name, software version, plugin version, and parser version are extracted from the semantic declaration of the capabilities provided as tool identity information. The native asset types declared in the provided capability semantics declaration and their positioning rules within the native file are parsed, and the native data positioning expression is compiled. Establish a mapping index between the semantic identifier of the capability and the native data location expression.

4. The method according to claim 3, characterized in that, The compatibility negotiation between the capability requirement semantic declaration generated by the business node and the available capability semantic declaration includes: The capability requirement semantic identifier in the capability requirement semantic declaration is matched and determined with the available capability semantic identifier in the available capability semantic declaration; If the semantic identifier matches successfully, the physical constraint determination, version compatibility determination, and runtime environment availability determination are performed sequentially. Based on the passing results of each judgment, the native data access strategy is determined.

5. The method according to claim 4, characterized in that, Based on the pass / fail results of each judgment, the native data access strategy is determined, including: If the downstream business node supports receiving the upstream native asset format and the operating environment is compatible, then the native data access strategy is determined to be the native pass-through strategy. If the downstream business node does not support receiving the upstream native asset format, and the native data location expression supports reading within a specified range, then the native data access strategy is determined to be an on-demand parsing strategy. If the required capability semantics are not directly stored in the native data, but are obtained through calculations using existing fields in the native data, then the native data access strategy is determined to be a local derivation strategy. If none of the above strategies are satisfied and only the data within the request scope needs to be format converted, then the native data access strategy is determined to be a local conversion strategy.

6. The method according to claim 5, characterized in that, For semantic declarations generated through compatibility negotiation, runtime semantic binding instances are generated, including: Obtain the normalized hash value of the current execution environment as the environment fingerprint; The semantic identifiers corresponding to the capability requirement semantic identifiers and the available capability semantic identifiers that are successfully matched in the compatibility negotiation are used as the business semantic identifiers. The business semantic identifier, the native asset reference, the native data location expression, the parser identifier, the available capability semantic declaration version, and the environment fingerprint are encapsulated into a lightweight description object, which serves as the runtime semantic binding instance. Generate a binding dependency signature based on the business fields, capability semantic declaration fields, and environment fields that the runtime semantic binding instance depends on, and associate the binding dependency signature with the runtime semantic binding instance.

7. The method according to claim 6, characterized in that, Based on the native asset reference and the native data location expression in the runtime semantic binding instance, access the plugin native data of the plugin native data domain, including: When the native data access strategy is an on-demand parsing strategy, the corresponding parser is invoked according to the parser identifier recorded in the runtime semantic binding instance; The parser uses the native data location expression to locate the target dataset in the native file pointed to by the native asset reference; The data specified by the capability requirement semantic declaration is read either by streaming or by projecting from the target dataset.

8. The method according to claim 6, characterized in that, The method further includes: When a change is detected in the business logic data field or the plugin's native data field, a change signature is generated; The change signature is compared with the binding dependency signature of each runtime semantic binding instance to identify the target runtime semantic binding instance whose dependency field intersects with the change signature; Perform revalidation or renegotiation on the target runtime semantic binding instance, while keeping the data state of the unaffected runtime semantic binding instance and the other data domain unchanged.

9. The method according to claim 8, characterized in that, Performing revalidation or renegotiation on the target runtime semantic binding instance includes: Check whether the modified capability semantics declaration provides the original business semantics, whether the native data location expression remains valid, and check whether the parser supports the current software version and operating environment. If the verification passes, update the version information in the target runtime semantic binding instance; If the verification fails, the target runtime semantic binding instance is determined to be invalid, and compatibility negotiation is re-executed based on the current plugin native data domain to generate a new runtime semantic binding instance.

10. A heterogeneous CAE workflow data management system, characterized in that, The system applicable to the method of any one of claims 1-9 comprises: The independent data domain construction module is used to construct the business logic data and plugin native data in the CAE simulation process into independent business logic data domains and plugin native data domains, respectively. The semantic negotiation and binding module is used to load the semantic declaration of the capabilities that the plugin can provide, and to perform compatibility negotiation between the semantic declaration of capability requirements generated by the business node and the semantic declaration of the capabilities that can be provided, and to generate a runtime semantic binding instance for the semantic declarations that pass the compatibility negotiation; the runtime semantic binding instance includes at least a business semantic identifier, a native asset reference and the native data location expression; The plugin native data access module is used to access the plugin native data in the plugin native data domain based on the native asset reference and the native data location expression in the runtime semantic binding instance.