Catia data conversion method and system for CAE preprocessing modeling software
By constructing a conversion framework that integrates parametric semantic parsing, deep learning repair, and a general digital thread protocol, the problems of geometric information loss, topological defects, and low efficiency in processing large assemblies during the conversion of Catia data to CAE software are solved. This achieves efficient and automated data conversion and fusion, improving the iterative efficiency of the CAD and CAE processes.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- KUNLUN DIGITAL (SHANGHAI) INFORMATION TECH CO LTD
- Filing Date
- 2026-03-14
- Publication Date
- 2026-05-15
AI Technical Summary
Existing technologies suffer from problems such as loss of geometric information, frequent topological defects, low efficiency in processing large assemblies, and a disconnect between design semantics and analysis requirements during the conversion of Catia data to CAE software, which limit the closed-loop iteration efficiency of the CAD and CAE processes.
By constructing a conversion framework that integrates parametric semantic parsing, deep learning repair, and a general digital thread protocol, high-fidelity, automated, and intelligent data fusion between the design and simulation ends is achieved. This includes model loading, parametric semantic parsing, geometric representation conversion, deep learning geometric repair, USD digital thread construction, and accuracy adaptive control.
It significantly improves the efficiency of parametric iteration, reduces the workload of manual repair, ensures the continuity and stability of mesh generation, supports the efficient conversion and collaborative editing of massive parts, and breaks down the data barriers between the design and simulation ends.
Smart Images
Figure CN121835034B_ABST
Abstract
Description
Technical Field
[0001] This invention belongs to the field of data integration technology of computer-aided engineering (CAE) and computer-aided design (CAD), and specifically relates to a Catia data conversion method and system for CAE preprocessing modeling software. Background Technology
[0002] In the modern high-end manufacturing sector, the construction of a digital product R&D system has become crucial for enhancing a company's core competitiveness. The collaborative operation of computer-aided design and computer-aided engineering permeates the entire product design lifecycle. With the deepening of industrial digitalization, the deep integration of high-precision 3D modeling and complex simulation analysis is of decisive significance for shortening R&D cycles and reducing testing costs. This necessitates establishing an efficient and high-fidelity data flow and sharing mechanism between different industrial software platforms.
[0003] Catia, as a mainstream 3D modeling tool in industries such as aerospace and automotive manufacturing, carries a massive amount of product design features and key parametric information, while CAE preprocessing software is responsible for transforming these geometric entities into analytical models that can be used for numerical calculations. The core objective of this data conversion technology from the design end to the analysis end is to ensure the integrity of geometric accuracy, preserve the original design intent, and dynamically adapt to the specific simulation requirements of subsequent mesh generation and boundary condition settings.
[0004] Existing technologies have the following drawbacks in converting Catia data to CAE software:
[0005] First, the data exchange protocol relies too heavily on traditional neutral file formats, which results in the loss of a large amount of high-level feature trees and design parameters, even though the underlying geometric data is preserved. This causes the converted model to lose its ability to be parametrically modified and iterated quickly.
[0006] Secondly, topological defects occur frequently during the geometric transformation process. Problems such as surface overlap and geometric cracks seriously interfere with the continuity of mesh generation, resulting in a huge amount of manual repair work and low efficiency.
[0007] Furthermore, for complex and large assemblies containing thousands of parts, the existing interface's memory management and processing mechanisms are not optimized enough, making it prone to conversion interruptions or system crashes.
[0008] Finally, there is a lack of a correlation mechanism between the geometric constraint semantics at the design end and the analytical requirement semantics at the simulation end, resulting in obvious engineering data silos.
[0009] These issues collectively limit the closed-loop iteration efficiency of the CAD and CAE processes. Therefore, it is particularly important to develop a conversion system that can preserve parametric semantics, achieve intelligent defect repair, and support digital thread collaboration. Summary of the Invention
[0010] The purpose of this invention is to provide a data conversion method and system for engineering simulation preprocessing modeling software, which can effectively solve the problems mentioned in the background art. Addressing the core structural problems in existing technologies, such as geometric information loss, frequent topological defects, low processing efficiency of large assemblies, and a disconnect between design semantics and analysis requirements, during data interaction between the first modeling software and simulation analysis software, this invention achieves high-fidelity, automated, and intelligent data fusion between the design and simulation ends by constructing a conversion framework integrating parametric semantic parsing, deep learning repair, and a general digital thread protocol.
[0011] To achieve the above objectives, the technical solution adopted by the present invention is as follows:
[0012] A data conversion method for engineering simulation preprocessing modeling software includes:
[0013] Step S1: Model loading and environment initialization. Load the target model file and turn off user interaction prompts. If the target model is an assembly, recursively traverse the product structure tree to build an assembly level index table.
[0014] Step S2: Parametric semantic parsing. The depth-first traversal algorithm is used to extract feature objects in the model. The size parameters, positioning reference and Boolean operation type of standard modeling features are obtained through the Catia API. The process parameters of non-standard features are parsed by tracing the parent operation history. A globally unique identifier ID is assigned to each feature to build a structured semantic data model.
[0015] Step S3: Geometric representation transformation and topology construction. Export the geometric entities inside each part and reconstruct them into a standard boundary representation B-Rep data structure. Construct a face-edge adjacency table and an edge-vertex connection table, and perform topology verification to generate a defect index table.
[0016] Step S4: Deep learning geometric repair. The B-Rep data is converted into a geometric representation tensor and input into a pre-trained convolutional autoencoder model to identify defect regions. The corresponding geometric repair strategy is called according to the defect mask output by the model to generate repaired B-Rep geometric data.
[0017] Step S5: USD digital thread construction, create a Stage instance based on the OpenUSD standard, create a MeshPrim record in the geometry layer to record the repaired geometry data, create an independent Prim record in the parametric semantic layer to record the structured semantic data model, and establish a bidirectional mapping relationship between the geometry layer and the semantic layer;
[0018] Step S6: Accuracy adaptive control. Construct a feature importance evaluation list based on the CAE analysis type, perform geometric simplification on non-critical features, and set the local mesh size according to the feature category, while maintaining the mapping relationship between feature identifier ID and geometric entity.
[0019] Step S7: Data export. Call the export adapter corresponding to the target CAE software to convert Mesh Prim into node and cell definition files, and export the feature parameters as feature identifiers and analysis parameter mapping data.
[0020] This invention also relates to a Catia data conversion system for CAE preprocessing modeling software, comprising:
[0021] The environment initialization module is used to call the COM interface to load the Catia model and build the assembly hierarchy index.
[0022] The semantic parsing module is used to perform a deep traversal of the feature tree and extract feature parameters to build a structured semantic data model;
[0023] The geometry transformation module is used to construct the B-Rep topology and perform topology defect verification;
[0024] The deep learning repair module is used to perform pixel-level identification of geometric defects and local topology repair using a convolutional autoencoder model.
[0025] The USD building block is used to organize the geometry layer and parametric semantic layer based on the OpenUSD standard and establish a bidirectional mapping relationship.
[0026] The precision control module is used to perform feature importance-based geometric simplification and mesh size preset;
[0027] The data export module is used to export mesh models and feature identifiers and analysis parameter mapping files according to the target CAE software format.
[0028] Compared with the prior art, the beneficial effects of the present invention are as follows:
[0029] This invention effectively breaks down the data barriers between the design and simulation ends by constructing a deeply integrated intelligent conversion architecture.
[0030] First, through the parametric semantic parsing module, a leap from single geometric transformation to full feature semantic transformation is achieved, so that the simulation model is no longer a rigid static geometry, but has the ability to be updated synchronously with the original design model, which significantly improves the efficiency of parametric iteration in the product development process, and greatly improves the retention rate of editable features of the transformed model.
[0031] Secondly, a deep learning repair module is introduced, which utilizes the powerful pattern recognition and shape reconstruction capabilities of artificial intelligence to automatically handle complex topological defects that are difficult for traditional algorithms to handle. This significantly reduces the workload of manual intervention in repair, ensures the continuity and stability of the downstream mesh generation process, and significantly reduces the geometric defect rate.
[0032] Furthermore, the layered loading and association mechanism based on the general digital thread protocol effectively solves the memory bottleneck problem when processing large and complex assemblies, supports efficient concurrent conversion and collaborative editing of massive parts, and greatly expands the application scale of the system. Attached Figure Description
[0033] Figure 1 This is a schematic diagram of the overall technical architecture of Catia data conversion and system, a CAE preprocessing modeling software proposed in this invention. Detailed Implementation
[0034] To further illustrate the technical means and effects of the present invention in achieving its intended purpose, the following detailed description of the specific implementation methods, structures, features, and effects of the present invention, in conjunction with the accompanying drawings and preferred embodiments, is provided below.
[0035] First, in the model loading and environment initialization phase, such as Figure 1The model loading and environment initialization module starts running. This module establishes a communication connection with the Catia application by calling the COM interface (Component Object Model) provided by Catia V5. Specifically, it creates an application instance using CreateObject("CATIA.Application") and sets Application.Visible = False to disable the graphical interface display, improving automation efficiency. Then, it calls the Documents.Open method to load the user-specified CATProduct or CATPart file and obtains the currently active document object, ActiveDocument. To avoid pop-up windows indicating file version incompatibility or missing references interfering with the automation process, this module disables all user interaction prompts by setting Application.DisplayFileAlerts = False and Application.StatusBar = False. Next, it creates a Selection object and initializes the search filter, limiting subsequent operations to specific node types such as Part, HybridBody, and ShapeFeature. If the input model is an assembly (CATProduct), the product structure tree is recursively traversed, each sub-product (Product) and its associated part (Part) objects are read in turn, and an assembly hierarchy index table containing hierarchical paths, part names and instance references is constructed to provide structural context for subsequent semantic parsing.
[0036] Entering the parametric semantic parsing phase, this module employs a depth-first traversal algorithm, starting from the root node `Part` and sequentially visiting all feature objects under container nodes such as `HybridBodies`, `Bodies`, and `ShapeFactory`. During traversal, the `Type` attribute of a feature identifies whether it is a standard modeling feature, such as `Hole`, `Pocket`, `Pad`, `Fillet`, and `Chamfer`. For standard features, the corresponding interfaces in the Catia API are called to extract parameters: for example, for the `Hole` feature, `Hole.Diameter`, `Hole.Depth`, `Hole.AxisDirection`, and `Hole.ReferencePlane` are called to obtain the size, depth, direction vector, and positioning reference; for the `Fillet` feature, the `Radius` value and the set of edges it affects are obtained. Simultaneously, the `Feature.GetConstraints()` interface is used to obtain the constraint relationships (such as concentricity, coplanarity, distance, etc.) between the feature and other geometries, and `Feature.BooleanOperationType` is used to determine its Boolean operation type (addition, subtraction, intersection). For non-standard or custom features (such as surface features created through the Generative Shape Design module), the parent operation history is traced through Feature.Parent, and Feature.GetTechnologicalObject() is called to parse the underlying modeling records and extract process parameters such as sketches, reference surfaces, and stretching directions that the feature depends on. In assembly scenarios, this module also traverses the Product constraint set to extract the mating types between parts (such as Contact, Offset, Angle), kinematic pair parameters (rotation axis, translation direction), and the number of constrained degrees of freedom. For each identified feature, a globally unique feature identifier ID is assigned (e.g., using UUID or "PartName_FeatureIndex" format), and the feature type, parameter set (stored in key-value pairs), reference to the associated geometry (pointing to the BRep entity), and topological association reference (such as other feature IDs involved in Boolean operations) are encapsulated into a structured semantic data model and temporarily stored in an in-memory data structure.
[0037] Simultaneously, the geometry representation conversion module performs geometric data extraction and topology construction. This module calls Catia's geometry kernel interface (such as HybridShapeFactory or ShapeFactory's ExportGeometry method) to export all geometric entities within each Part, including NURBS surfaces, boundary curves (Edges), and vertices. Subsequently, this raw geometric data is reconstructed into a standard boundary representation (B-Rep) data structure. Specifically, a vertex set V = {v1, v2, ..., v} is established. n}, where each vertex contains three-dimensional coordinates (x, y, z); establish an edge set E = {e1, e2, ..., e}. m Each edge is defined by a starting vertex, a ending vertex, and a parametric curve equation; establish a face set F = {f1, f2, ..., f...} k Each face is composed of a boundary loop, and each loop consists of an ordered sequence of edges. Based on this, a Face-Edge Adjacency Table and an Edge-Vertex Connectivity Table are constructed to form a complete topological data model. Then, topological verification is performed: non-manifold edges are identified by traversing all edges to check if they are exactly shared by two faces; flipped faces are detected by calculating the normal vector of each face and verifying the consistency of normal vectors between adjacent faces; duplicate or overlapping faces are detected using a spatial hash algorithm; and closed loop detection is used to determine if an entity is closed. If an anomaly is found, the defect location and type are recorded, and a defect index table is generated.
[0038] Subsequently, a deep learning-based geometric repair module intervenes. This module first converts the aforementioned B-Rep data into a geometric representation form that can be processed by a convolutional autoencoder network. Specifically, a voxelization method is used: the bounding box is divided into a 256×256×256 three-dimensional mesh, and for each voxel, it is determined whether it is located inside the entity (using ray casting), generating a binary voxel tensor; or a multi-view projection method is used: depth images are rendered from 12 evenly distributed viewpoints, generating a 12-channel depth map sequence. This representation data is then input into a pre-trained convolutional autoencoder model (this model has been trained on a dataset containing tens of thousands of defective CAD models and can output pixel-level defect masks and defect type classification results, such as cracks, overlaps, and non-manifolds). Based on the network output, the corresponding repair strategy is invoked: if it is a crack defect (manifested as a non-closed boundary), the boundary curves on both sides of the crack are extracted, a transition surface is generated by B-spline fitting, and local Boolean fusion is performed; if it is an overlapping surface, the overlapping area is identified, and Boolean difference operation is performed to remove redundant parts; if it is a non-manifold topology (such as three edges intersecting at a point), the shared vertices are split and the local connectivity is reconstructed. After the repair is completed, the B-Rep topology is reconstructed, the repaired B-Rep geometric data is generated, and the Hausdorff distance between the corresponding geometric entities before and after the repair is calculated to quantify the geometric deviation, ensuring that the repair accuracy meets CAE requirements (usually controlled within 1% of the original feature size).
[0039] Next, the USD digital thread building module organizes data based on the OpenUSD standard. First, a USD Stage instance is created, and a default Prim path is defined. In the geometry layer, an Xform Prim (e.g., " / EngineBlock / Part1") is created for each part, and a Mesh Prim (e.g., " / EngineBlock / Part1 / Mesh") is created under it. The repaired B-Rep data is converted into a triangular mesh (discretized via the Catia Tessellation interface or a third-party library such as OpenCASCADE), and vertex coordinates are written to the Points attribute, face indices to FaceVertexIndices, and the number of vertices per face to FaceVertexCounts. In the parametric semantic layer, an independent Prim (e.g., " / Semantics / Part1_Hole_001") is created for each feature, and parameters from the structured semantic data model are written in USD Attribute form, such as doubleradius = 5.0, string type = "Hole", int[] affectedFaces = [12, 15, 18]. The key lies in establishing the connection between the geometric and semantic layers: this is achieved by defining a Relationship (e.g., "semanticBinding") under the Mesh Prim pointing to the corresponding semantic Prim path, or by using custom namespace attributes (e.g., "catia:featureId" = "Part1_Hole_001") to realize a bidirectional mapping between feature identifiers and geometric entities. Furthermore, based on the target CAE software type (e.g., Abaqus), an analysis adaptation layer Prim (e.g., " / Analysis / Abaqus") is created in the Stage, and material properties (density=7800, youngsModulus=210e9), element type (C3D8R), and default boundary condition metadata are written into it.
[0040] Subsequently, the accuracy adaptive control module performs feature-level simplification based on the user-input CAE analysis type parameters (such as "static structural analysis"). This module first constructs a feature importance assessment list: it iterates through all features, determining whether they are located on load transfer paths (through preliminary finite element stress cloud maps or geometric connectivity analysis), whether they constitute fluid domain boundaries (in CFD analysis), or whether they belong to interfaces between different materials. For non-critical features (such as decorative small chamfers or tiny holes on internal stiffeners), geometric simplification is performed: fillets with radii less than 0.5 mm are deleted, adjacent chamfers with similar radii are merged, and pockets completely enclosed within the solid are removed. Simultaneously, local mesh sizes are set according to feature categories: a mesh size of 1 mm is set for critical stress areas (such as around bolt holes), and 5 mm is set for non-critical areas. During simplification and mesh adjustment, the mapping relationship between the structured semantic data model and geometric entities is maintained through feature identifier IDs, and the reference index of the Mesh Prim in the geometric layer is updated to ensure that semantic information is not lost.
[0041] Finally, the data export module reads the complete OpenUSD layered data structure and calls the corresponding export adapter based on the target CAE software type. Taking Abaqus as an example, it iterates through all Mesh Prim in the geometry layer, extracts Points and FaceVertexIndices to generate node (*Node) and element (*Element) definitions, and writes them to the .inp file. Simultaneously, it iterates through the parameter semantic layer, writing the ID, type, key parameters (such as aperture and thickness), and corresponding mesh region (mapped to the element set via affectedFaces) of each feature into an additional parameter mapping file (such as .json or .csv format), forming feature identification and analysis parameter mapping data. This mapping data can be directly called by the CAE preprocessing software in subsequent optimizations, for example, linking aperture parameters to design variables to achieve parametric simulation-driven design.
[0042] Throughout the process, modules transfer data via shared memory data structures or intermediate files, ensuring strict synchronization between geometric data and semantic information in the conversion, repair, simplification, and export stages. Through the specific implementation methods described above, this invention achieves high-fidelity, highly automated, and semantically traceable data conversion from native Catia models to CAE analysis input, effectively solving technical bottlenecks such as loss of design intent, frequent geometric defects, and difficulties in handling large assemblies in traditional STEP / IGES format conversion.
[0043] All content not described in detail in the specification belongs to the prior art known to those skilled in the art, and the software interfaces and algorithm parameters are not specifically limited. They can be implemented using conventional development tools and libraries. The underlying data structures and communication protocols not mentioned in this technical solution are not shown in the figure because they belong to the prior art, and will not be described here.
Claims
1. A method for data conversion in Catia, a CAE preprocessing modeling software, characterized in that, Includes the following steps: Step S1: Model loading and environment initialization. Load the target model file and turn off user interaction prompts. If the target model is an assembly, recursively traverse the product structure tree to build an assembly level index table. Step S2: Parametric semantic parsing. The depth-first traversal algorithm is used to extract feature objects in the model. The size parameters, positioning reference and Boolean operation type of the standard modeling features are obtained through CatiaAPI. The process parameters of non-standard features are parsed by tracing the parent operation history. A globally unique identifier ID is assigned to each feature to build a structured semantic data model. Step S3: Geometric representation transformation and topology construction. Export the geometric entities inside each part and reconstruct them into a standard boundary representation B-Rep data structure. Construct a face-edge adjacency table and an edge-vertex connection table, and perform topology verification to generate a defect index table. Step S4: Deep learning geometric repair. The B-Rep data is converted into a geometric representation tensor and input into a pre-trained convolutional autoencoder model to identify defect regions. The corresponding geometric repair strategy is called according to the defect mask output by the model to generate repaired B-Rep geometric data. Step S5: USD digital thread construction, create a Stage instance based on the OpenUSD standard, create a Mesh Prim record in the geometry layer to record the repaired geometry data, create an independent Prim record in the parametric semantic layer to record the structured semantic data model, and establish a bidirectional mapping relationship between the geometry layer and the semantic layer; Step S6: Accuracy adaptive control. Construct a feature importance evaluation list based on the CAE analysis type, perform geometric simplification on non-critical features, and set the local mesh size according to the feature category, while maintaining the mapping relationship between feature identifier ID and geometric entity. Step S7: Data export. Call the export adapter corresponding to the target CAE software to convert Mesh Prim into node and cell definition files, and export the feature parameters as feature identifiers and analysis parameter mapping data.
2. The Catia data conversion method for CAE preprocessing modeling software according to claim 1, characterized in that, Step S1 specifically includes: creating a Catia application instance using the CreateObject method and setting the graphical interface to be invisible; setting the DisplayFileAlerts property to False to block the prompt windows for file version incompatibility and missing references; and initializing the search filter using the Selection object to limit the search scope to Part, HybridBody, and ShapeFeature nodes.
3. The Catia data conversion method for CAE preprocessing modeling software according to claim 1, characterized in that, In step S2, the structured semantic data model stores feature parameters in key-value pairs and includes references to BRep entities and topological association references to other feature IDs participating in Boolean operations.
4. The Catia data conversion method for CAE preprocessing modeling software according to claim 1, characterized in that, The topology verification in step S3 includes: checking non-manifold edges by traversing all edges; detecting flipped surfaces by verifying the consistency of normals of adjacent surfaces; detecting overlapping surfaces by using a spatial hash algorithm; and determining the closure of entities by detecting closed loops.
5. The Catia data conversion method for CAE preprocessing modeling software according to claim 1, characterized in that, Step S4 specifically includes: using a voxelization method to divide the bounding box into a three-dimensional mesh to generate a binary voxel tensor, or using a multi-view projection method to generate a multi-channel depth map sequence as input; the repair strategy includes B-spline fitting to generate a transition surface for crack defects, performing Boolean difference operations on overlapping surfaces, and splitting shared vertices for non-manifold topology; after the repair is completed, the Hausdorff distance between the geometric entities before and after the repair is calculated to verify whether the geometric deviation is within the preset accuracy range.
6. The Catia data conversion method for CAE preprocessing modeling software according to claim 1, characterized in that, In step S5, the bidirectional mapping association is established by defining a Relationship pointing to the semantic Prim path under Mesh Prim, or by recording the globally unique identifier ID in the geometry layer through a custom namespace attribute.
7. The Catia data conversion method for CAE preprocessing modeling software according to claim 1, characterized in that, Step S5 further includes: creating an analysis adaptation layer Prim in the OpenUSD Stage for writing material properties, element type metadata, and boundary conditions.
8. The Catia data conversion method for CAE preprocessing modeling software according to claim 1, characterized in that, In step S6, the feature importance assessment is achieved by analyzing whether the feature is located on the load transfer path, whether it constitutes a fluid domain boundary, or whether it belongs to a material interface; for the identified non-critical features, simplified operations such as deleting small-sized chamfers, merging adjacent chamfers, or removing internal closed grooves are performed.
9. A Catia data conversion system for CAE preprocessing modeling software, characterized in that, include: The environment initialization module is used to call the COM interface to load the Catia model and build the assembly hierarchy index. The semantic parsing module is used to perform a deep traversal of the feature tree and extract feature parameters to build a structured semantic data model; The geometry transformation module is used to construct the B-Rep topology and perform topology defect verification; The deep learning repair module is used to perform pixel-level identification of geometric defects and local topology repair using a convolutional autoencoder model. The USD building block is used to organize the geometry layer and parametric semantic layer based on the OpenUSD standard and establish a bidirectional mapping relationship. The precision control module is used to perform feature importance-based geometric simplification and mesh size preset; The data export module is used to export mesh models and feature identifiers and analysis parameter mapping files according to the target CAE software format.