A general finite element model conversion method

Abstract

This invention discloses a general finite element model conversion method, including: hierarchical flattening and global renumbering; element type regrouping; material analysis and classification code solidification; multi-dimensional attribute aggregation; recursive expansion of indirect surface references; and three-layer load normalization. The general finite element model conversion method provided by this invention, through a six-step chain-like forward conversion scheme, transforms the software input organization oriented towards modeling into a data organization oriented towards solution; simultaneously, the COT file, as the conversion result, retains necessary semantics, providing a foundation for subsequent on-demand reorganization.

Description

Technical Field

[0001] This invention relates to the field of computer-aided engineering technology, and in particular to a general finite element model conversion method. Background Technology

[0002] Finite element analysis is widely used in engineering scenarios such as automotive collision safety, aerospace bird strike analysis, metal forming, and explosion impact. Different commercial software (Abaqus, LS-DYNA, NASTRAN, etc.) have each defined their own independent input file formats, and the data organization methods between the formats are significantly different. For example: (1) Hierarchical and flat: Some formats (such as Abaqus INP) adopt a hierarchical structure of part-assembly-instance, while others (such as LS-DYNA K files) adopt a global flat numbering; (2) Distributed and inline: Properties such as material, section control, and load may be distributed in multiple independent keyword blocks (such as INP), or they may adopt a card-style inline with fixed column width (such as K files); (3) Indirect reference and direct reference: Data such as surface and load may be indirectly referenced through symbols such as set name and face label, or a list of nodes / faces may be given directly.

[0003] However, the data access requirements of numerical solvers during the computation phase are highly similar, such as: accessing data in batches by element type, reading complete computational properties element by element, traversing contact pairs by surface segment, and evaluating all loads by time step.

[0004] Currently, general-purpose computations based on different commercial software file formats typically employ the Abaqus INP format or internal preprocessing within various commercial solvers (Abaqus / Explicit, LS-DYNA, etc.). The former uses a keyword-based text format with a hierarchical instance structure; materials are defined by combinations of multiple independent keyword blocks; and surfaces use indirect references. The latter performs similar data reorganization operations internally after reading the input file, but these operations occur during solver runtime, resulting in a private memory structure and lacking a publicly defined, independently transferable, and reusable intermediate file format. Current general-purpose computations face the following technical challenges:

[0005] (1) Existing input files are organized in a scattered manner by parts, instances, sets, keyword blocks, etc., which cannot directly meet the solver's high-frequency access requirements by type, entity, and time step;

[0006] (2) Information such as materials, section control, surface and load in existing input files is usually indirectly related through names and hierarchical relationships, and a lot of preprocessing is still required after reading;

[0007] (3) Existing public data exchange formats can usually only "transfer data" and cannot simultaneously achieve "computation readiness" and "semantic preservation";

[0008] (4) The existing technology lacks a unified technical solution that can both serve the solver to read directly and retain the necessary structural semantics for subsequent data reconstruction.

[0009] Therefore, the core contradiction lies in the fact that existing input formats are designed for "pre-processing software and human editing," and their data organization methods have a systematic gap with the computational access mode of solvers. Currently, there is a lack of a universal finite element model conversion method to transform input data into a "computationally ready" expression oriented towards solver computation, while preserving as much of the key semantics required for subsequent reconstruction as possible. Summary of the Invention

[0010] To address the shortcomings of existing technologies, this invention provides a general finite element model conversion method. Through a six-step chain-like forward conversion scheme, the software input organization oriented towards modeling is converted into a data organization oriented towards solving. At the same time, the COT (Data Transfer Platform) file, which is the result of the conversion, retains the necessary semantics, providing a basis for subsequent on-demand reorganization.

[0011] This invention provides the following solutions:

[0012] This invention provides a general finite element model conversion method, the method comprising the following steps:

[0013] S1. Initialize the COT file; perform hierarchical flattening and global renumbering on the input file, generate a node mapping table, and write the node segment of the data transfer platform file.

[0014] S2. Perform type regrouping on the cells in the input file, and combine the node mapping table generated in step S1 to generate a type segmentation and cell mapping table.

[0015] S3. Perform material analysis and classification code solidification on the input file to generate classification codes and material mapping tables;

[0016] S4. Perform multi-dimensional attribute aggregation processing on the element mapping table generated in step S2 and the material mapping table generated in step S3 to generate element records.

[0017] S5. Combine the scope structure generated in step S1 with the recursive expansion operation of the cell mapping table generated in step S2 to generate the surface segment table and surface index.

[0018] S6. Based on the load definition in the input file, and according to the load application object, perform load three-layer normalization processing based on the node mapping table generated in step S1 or the surface index generated in step S5 to generate a three-layer load structure; write the node segments, type segments, complete element records, material records and classification codes, surface segment tables and the three-layer load structure into the COT file to obtain a calculation-ready intermediate data file of the finite element model.

[0019] Furthermore, step S1 specifically includes the following processes:

[0020] S1.1 Constructing the scope structure: Create a scope object for each instance in the input file and maintain two data source pointers, namely the template grid and the local grid; when multiple instances reference the same part, they share the same template to avoid data copying;

[0021] S1.2 Global Node Renumbering: Traverse each scope in the order of template grid first, then local grid, assign a new global consecutive number starting from 1 to each node, and at the same time establish a hash mapping table from scope information and old node ID to new node ID;

[0022] S1.3 Output Node Segment: Write the renumbered nodes into the node segment of the COT file according to the new global numbering order.

[0023] Furthermore, step S2 specifically includes the following processes:

[0024] S2.1. Traverse all output scopes formed after the hierarchical flattening in step S1, and collect the basic description information of each unit. The basic description information includes the scope identifier, old number, unit type and node list.

[0025] S2.2, Bucketing Phase: Using the unit type enumeration as the key, all units are divided into the corresponding type buckets;

[0026] S2.3 Numbering Phase: The cells in each type of bucket are numbered independently starting from 1. At the same time, the old IDs in the node list are converted into new global IDs through the node mapping table produced in S1.

[0027] S2.4 Mapping Construction: Establish a mapping relationship for each cell from its scope identifier and old number to the cell type enumeration and type local number, and generate a cell mapping table;

[0028] S2.5 Output Stage: Each type of output is an independent segment in the COT file, i.e., a generation type segment. The segment header information of the independent segment includes the segment name and the number of segments.

[0029] Furthermore, step S3 specifically includes the following processes:

[0030] S3.1 Material Attribute Collection: Collect all attribute blocks belonging to the same material, using the material name as the key;

[0031] S3.2 Parameter Standardization: Write the parameters in different keywords into standardized material records according to a unified field;

[0032] S3.3 Constitutive Type Determination: Execute the priority determination chain algorithm on the standardized material record to determine the constitutive type and generate a classification code;

[0033] S3.4 Numbering and Output Fixation: Assign a unique material number to each standardized material, output a compact material record, establish a mapping relationship between material name and material number, and generate a material mapping table.

[0034] Furthermore, step S4 specifically includes the following processes:

[0035] S4.1 Material Association: For the section definition associated with each element set, the material number is looked up in the material mapping table generated in step S3 by the material name;

[0036] S4.2 Control Parameter Association: For the control parameters associated with each section, extract the hourglass control mode and distortion control flag;

[0037] S4.3 Shell Thickness Association: Establish a thickness index table for the thickness values ​​in the shell section definition, and establish a mapping from elements to the thickness index;

[0038] S4.4 Output format: Write the node number, material number, control parameters and thickness index into the unit record with a fixed format.

[0039] Furthermore, step S5 specifically includes the following processes:

[0040] S5.1 Set Recursive Expansion: Recursively parse the cell set names in the input file into a list of old cell IDs;

[0041] S5.2 Type Lookup and ID Conversion: For each old unit ID after expansion in step S5.1, look up its type enumeration and type local ID through the mapping table in S2;

[0042] S5.3, Face Node Mapping: Based on the element type and face label, determine the face definition from the predefined face node definition table; the face node definition table defines the mapping relationship from face number to node local index for each supported element type;

[0043] S5.4 Surface Segment Record Output: Write the surface segment information into the surface segment table of COT. The surface segment information includes the surface segment number, element type code, type local number, and surface number.

[0044] S5.5 Surface Index Construction: Map each surface name to its surface object record number in the output to generate a surface index.

[0045] Furthermore, step S6 specifically includes the following processes:

[0046] S6.1, THF (Time History Function) Extraction: If the load references an amplitude definition, the existing THF is reused; otherwise, a default THF is created.

[0047] S6.2 LoadOBJ (Load Object) Generation: Combine the loading method of the load with the THF number. The loading method includes the type code, degree of freedom direction and reference amplitude.

[0048] S6.3 LoadDisp (Load Allocation) Expand: Expand the load's target object into a record-by-record using the node mapping table generated in step S1 and / or the surface index generated in step S5. The target object is a set of nodes or a surface name.

[0049] The beneficial effects of this invention based on its technical solution are as follows:

[0050] This invention first completes the preprocessing required by the solver during the file conversion stage, solidifying the preprocessing results into a publicly defined, independently storable intermediate format, and retaining the key semantics needed for subsequent reorganization within this intermediate format. Compared with existing technologies, this invention does not simply "rewrite" the input file, but rather completes the following three types of substantial reorganization:

[0051] (1) Reorganize hierarchical and locally numbered data into globally unified numbered data;

[0052] (2) Reorganize the attributes scattered in multiple keyword blocks into records that can be directly consumed by the entity;

[0053] (3) Reorganize the name-driven, syntax-splitting reference relationships into integer numbers, type codes, and normalized parameter areas.

[0054] Therefore, COT files can be directly used by the solver for reading and can also serve as the semantic basis for subsequent on-demand reorganization, thus achieving the dual effect of "computational readiness + semantic preservation". Attached Figure Description

[0055] To more clearly illustrate the technical solutions in the embodiments of this specification or the prior art, the drawings used in the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this specification. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0056] Figure 1 This is a flowchart illustrating a general finite element model conversion method provided by the present invention.

[0057] Figure 2 This is a schematic diagram of a three-layer normalized load structure. Detailed Implementation

[0058] The technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings of the embodiments of the present invention. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. All other embodiments obtained by those skilled in the art based on the embodiments of the present invention are within the protection scope of the embodiments of the present invention.

[0059] This embodiment provides a general finite element model conversion method, referring to... Figure 1 The method includes the following steps:

[0060] S1. Initialize the COT file; perform hierarchical flattening and global renumbering on the input file, generate a node mapping table, and write it to the node segment of the data transfer platform file. Specifically, this includes the following processes:

[0061] S1.1 Constructing the scope structure: Create a scope object for each instance in the input file and maintain two data source pointers, namely the template grid and the local grid; when multiple instances reference the same part, they share the same template to avoid data copying;

[0062] S1.2 Global Node Renumbering: Traverse each scope in the order of template grid first, then local grid, assign a new global consecutive number starting from 1 to each node, and at the same time establish a hash mapping table from scope information and old node ID to new node ID;

[0063] S1.3 Output Node Segment: Write the renumbered nodes into the node segment of the COT file according to the new global numbering order.

[0064] Taking the INP file as an example, this input file format adopts a hierarchical structure of "part definition + instance reference": Part-A and Part-B, which define nodes and elements independently, are used to define the parts. The assembly references the part template through the instance and applies displacement or rotation.

[0065] In this embodiment, the original Part-A nodes were numbered 1 to 50, and the Part-B nodes were numbered 1 to 30. After renumbering, the new global numbers for the two modules are 1 to 50 and 51 to 80, respectively, for a total of 80 nodes, with consecutive and non-repeating numbers.

[0066] The fundamental problem solved by hierarchical flattening is cross-part numbering conflicts. In an INP, node 1 of Part-A and node 1 of Part-B are different physical nodes, but they have the same number. If the numbering is not recalculated, all subsequent operations that index data by number will fail to execute correctly. Global consecutive numbering allows the number itself to be used as an array index (number - 1 = index), eliminating the need for hash lookups.

[0067] After such renumbering, all node numbers in COT are globally unique and continuous, and the numbers can be directly used as array subscripts to achieve O(1) direct indexing; the numbering conflict across parts is eliminated, and subsequent steps (S2~S6) can uniformly use the new global number; the node mapping table provides the old to new number conversion with an algorithm complexity of only O(1) for subsequent S2 and S6.

[0068] S2. Perform type regrouping on the cells in the input file, and combine it with the node mapping table generated in step S1 to generate type segmentation and cell mapping tables. Specifically, this includes the following processes:

[0069] S2.1. Traverse all output scopes formed after the hierarchical flattening in step S1, and collect the basic description information of each unit. The basic description information includes the scope identifier, old number, unit type and node list.

[0070] S2.2, Bucketing Phase: Using the unit type enumeration as the key, all units are divided into the corresponding type buckets;

[0071] S2.3 Numbering Phase: The cells in each type of bucket are numbered independently starting from 1. At the same time, the old IDs in the node list are converted into new global IDs through the node mapping table produced in S1.

[0072] S2.4 Mapping Construction: Establish a mapping relationship for each cell from its scope identifier and old number to the cell type enumeration and type local number, and generate a cell mapping table;

[0073] S2.5 Output Stage: Each type of output is an independent segment in the COT file, i.e., a generation type segment. The segment header information of the independent segment includes the segment name and the number of segments.

[0074] In this embodiment, the units in the INP file are organized by part, and multiple types can be mixed within the same part. For example, Part-A contains units of the following types and quantities: C3D8×20 and C3D4×5; Part-B contains units of the following types and quantities: C3D4×3 and S4R×2. After regrouping, all units are regrouped by type and output as independent segments. The segment name and quantity fields in the COT file are recorded as follows:

[0075] TotalSolidNLH8s,20;

[0076] TotalSolidNLT4s,8;

[0077] TotalShellNLQS,2.

[0078] Different cell types differ fundamentally in the number of nodes, record fields, and calculation methods. Mixing different types means that each record has an inconsistent format, requiring type determination for each record during reading. Segmenting by type ensures that all records within the same segment have identical formats, allowing for reading in a fixed step-size order. The segment header "segment name, quantity" further encodes type and quantity information, enabling the solver to determine the processing method and required memory size for that segment after reading the header.

[0079] After regrouping, all cell records within the same segment have a unified format and can be read sequentially with a fixed step size; the segment header carries the precise quantity and supports one-time memory pre-allocation; the segment header type identifier can provide a basis for cell type for subsequent on-demand reorganization.

[0080] S3. Perform material analysis and classification code solidification on the input file to generate a classification code and material mapping table. This process includes the following steps:

[0081] S3.1 Material Attribute Collection: Collect all attribute blocks belonging to the same material, using the material name as the key;

[0082] S3.2 Parameter Standardization: Write the parameters in different keywords into standardized material records according to a unified field;

[0083] S3.3 Constitutive Type Determination: Execute the priority determination chain algorithm on the standardized material record to determine the constitutive type and generate a classification code;

[0084] S3.4 Numbering and Output Fixation: Assign a unique material number to each standardized material, output a compact material record, establish a mapping relationship between material name and material number, and generate a material mapping table.

[0085] In this embodiment, a material in the INP file typically does not appear as a single complete record, but is defined by a combination of multiple independent keyword blocks. The task of this step is not simply to "determine the material type," but to first parse the scattered material definitions and form standardized material records, and then supplement the records with classification codes.

[0086] The fundamental problem addressed in this step is that the dispersed semantics of the material definition cannot directly drive the solver's constitutive calculations. This step first parses the discrete keywords into standardized material records, and then generates integer classification codes through a priority decision chain. In this way, the material is transformed from a "textual semantic combination" into a "numbered, categorized, and parameter-structured" record form, allowing the solver to assign the material segment to the corresponding constitutive branch according to the classification code.

[0087] After material analysis and classification code solidification, the integer classification code directly identifies the constitutive type, eliminating the need for text combination judgment; the standardized parameter area can serve as the source of structured parameters for subsequent material recombination; it provides a stable "material name → number" mapping for step S4, making the unit material association degenerate into a number lookup with a complexity of O(1).

[0088] S4. Perform multi-dimensional attribute aggregation processing on the element mapping table generated in step S2 and the material mapping table generated in step S3 to generate element records. This process includes the following steps:

[0089] S4.1 Material Association: For each ELSET (element set) associated with a section definition, the material number is looked up in the material mapping table generated in step S3 by the material name;

[0090] S4.2 Control Parameter Association: For each section-associated SectionControls (section control parameters), extract, for example, the hourglass control mode and distortion control flag;

[0091] S4.3 Shell Thickness Association: Establish a thickness index table for the thickness values ​​in the shell section definition, and establish a mapping from elements to the thickness index;

[0092] S4.4 Output format: Write the node number, material number, control parameters and thickness index into the unit record with a fixed format.

[0093] In this embodiment, taking the shell element of an INP file as an example, the complete properties of a single element are distributed across at least four different sources: material, section control, distortion control, and shell thickness. The task of this step is to correlate and converge these dispersed properties during the conversion phase.

[0094] Attribute aggregation addresses the fundamental problem of insufficient data locality. Under the decentralized organization of INPs, obtaining the complete computed attributes of a single cell requires accessing multiple locations, equivalent to performing a multidimensional JOIN. This step completes these associations all at once during the transformation phase, writing the results to the cell record, which is equivalent to a materialized view in a database.

[0095] After aggregation, all calculated attributes of the element are fully obtained within the continuous record, eliminating the need for cross-referencing during calculation; the inline material number and control parameters can provide a basis for subsequent reorganization of section definition and control parameter blocks.

[0096] S5. Combine the scope structure generated in step S1 with the cell mapping table generated in step S2 to perform a face indirect reference recursive expansion operation to generate a surface segment table and a surface index.

[0097] In the INP file, the surface definition uses an indirect reference method of "element set name + face label" (such as ELSET1, S3). To obtain specific data, multiple steps of expansion are often required. Using the steps of this embodiment, all expansions are completed at once, specifically including the following processes:

[0098] S5.1. Set recursive expansion: Recursively resolve the element set names in the input file into a list of old element IDs. The set may nestedly reference other sets or use a qualified name (Instance.SetName) to cross scopes, and the converter implements a complete recursive resolution.

[0099] S5.2. Type lookup and ID conversion: For each old element ID after the expansion in step S5.1, look up its type enumeration and type local ID through the mapping table in S2;

[0100] S5.3. Face node mapping: Determine the face definition from the predefined face node definition table according to the element type and face label; in the face node definition table, the mapping relationship from the face number to the node local index is defined for each supported element type (C3D4, C3D6, C3D8, C3D10, C3D15, C3D20, S3, S4R, etc.);

[0101] S5.4. Surface segment record output: Write the surface segment information into the TotalSurfaceSegs table (surface segment table) of COT. The surface segment information includes the face segment number, element type code, type local number, and face number;

[0102] S5.5. Surface index construction: Map each surface name to its 1-based number in the output to generate a surface index.

[0103] In this embodiment, when the element set ELSET1 [element 5, element 9, element 1] in the INP is recursively expanded and processed, the TotalSurfaceSegs segments obtained are shown as follows:

[0104] TotalSurfaceSegs,3:

[0105] 1, <C3D8 type code>, 33, 3 (indicating the new number 33 of element 5, face 3);

[0106] 2, <C3D8 type code>, 47, 3 (indicating the new number 47 of element 9, face 3);

[0107] 3, <C3D8 type code>, 58, 3 (indicating the new number 58 of element 12, face 3).

[0108] The first column above is the face segment number, the second column is the unit type code, the third column is the type local number, and the fourth column is the face number.

[0109] The fundamental problem addressed by surface precomputation is the runtime overhead of indirect references. Surface definitions in INPs often involve two levels of indirect references: first, the set name is resolved into a list of cells, and then the face label is resolved into face node indices. This step resolves all indirect references at once during the transformation phase, writing the results into directly accessible surface segment records, thus avoiding repeated expansion at runtime.

[0110] After recursive unrolling, the surface data is expanded from two levels of indirect references to specific surface segment records with zero indirect references; the cell type code, type local number, and face number in the record can support subsequent surface definition reorganization; contact-related reads can directly consume the surface segment table without repeatedly performing set unrolling.

[0111] S6. Based on the load definitions in the input file, and according to the load application object, perform load three-layer normalization processing based on the node mapping table generated in step S1 or the surface index generated in step S5 to generate a three-layer load structure; write the node segments, type segments, complete element records, material records and classification codes, surface segment table, and three-layer load structure into the COT file to obtain a computationally ready intermediate data file for the finite element model. Specifically, this includes the following processes:

[0112] S6.1, THF (Time History Function) Extraction: If the load references *AMPLITUDE (amplitude definition), the existing THF is reused; otherwise, a default THF is created.

[0113] S6.2 LoadOBJ (Load Object) Generation: Combine the loading method of the load with the THF number. The loading method includes the type code, degree of freedom direction and reference amplitude.

[0114] S6.3 LoadDisp (Load Allocation) Expand: Expand the load's target object into a record-by-record using the node mapping table generated in step S1 and / or the surface index generated in step S5. The target object is a set of nodes or a surface name.

[0115] Reference Figure 2The different load definitions in the input file are unified and normalized into a three-layer architecture: THF (Time History Function), LoadOBJ (Load Object), and LoadDisp (Load Allocation). Taking the typical implementation of INP as an example, *BOUNDARY (Boundary Condition Definition Keyword), *CLOAD (Concentrated Load Definition Keyword), and *DSLOAD (Distributed Surface Load Definition Keyword) each have independent syntax and time association methods, but physically they can all be decomposed into three dimensions: "how it changes over time," "how it is applied," and "where it is applied."

[0116] The fundamental problem addressed by load normalization in this step is load syntax fragmentation. Loads with different syntaxes can be physically decomposed into the three orthogonal dimensions mentioned above. After separating these three dimensions, each layer can be shared independently. For example, the same THF can be referenced by multiple LoadOBJs, and the same LoadOBJ can be referenced by multiple LoadDisps.

[0117] After the payload is normalized in three layers, the payload processing is simplified from parsing multiple special syntaxes to reading a unified three-layer structure; the sharing mechanism of THF and LoadOBJ avoids the repeated storage of time data and loading methods; the type code and semantic tags in the three-layer structure can support subsequent payload keyword reorganization.

[0118] First, the INP is converted into a computationally ready and semantically preserved intermediate format, COT. As long as a mapping relationship can be established between the target format and these preserved semantics, it can be recombined and output from COT according to the target format rules. The semantic information preserved in COT, such as type identifiers, material classification codes, standardized parameter areas, surface segment tables, and load three-layer structures, can support recombination into other finite element target formats according to the target format rules.

[0119] Those skilled in the art will understand that embodiments of the present invention can be provided as methods, systems, or computer program products. Therefore, the present invention can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention can take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0120] Although preferred embodiments of the invention have been described, those skilled in the art, upon learning the basic inventive concept, can make other changes and modifications to these embodiments. Therefore, the appended claims are intended to be interpreted as including both the preferred embodiments and all changes and modifications falling within the scope of the invention.

[0121] Obviously, those skilled in the art can make various modifications and variations to this invention without departing from its spirit and scope. Therefore, if these modifications and variations fall within the scope of the claims of this invention and their equivalents, this invention also intends to include these modifications and variations.

Claims

1. A universal finite element model conversion method, characterized by, The method includes the following steps: S1. Initialize the COT file; perform hierarchical flattening and global renumbering on the input file, generate a node mapping table, and write the node segment of the data transfer platform file. S2. Perform type regrouping on the cells in the input file, and combine the node mapping table generated in step S1 to generate a type segmentation and cell mapping table. S3. Perform material analysis and classification code solidification on the input file to generate classification codes and material mapping tables; S4. Perform multi-dimensional attribute aggregation processing on the element mapping table generated in step S2 and the material mapping table generated in step S3 to generate element records. S5. Combine the scope structure generated in step S1 with the recursive expansion operation of the cell mapping table generated in step S2 to generate the surface segment table and surface index. S6. Based on the load definition in the input file, and according to the load application object, perform load three-layer normalization processing based on the node mapping table generated in step S1 or the surface index generated in step S5 to generate a three-layer load structure; write the node segments, type segments, complete element records, material records and classification codes, surface segment tables and the three-layer load structure into the COT file to obtain a calculation-ready intermediate data file of the finite element model.

2. The general finite element model conversion method according to claim 1, characterized in that: Step S1 details The process includes the following: S1.1 Constructing the scope structure: Create a scope object for each instance in the input file, and maintain two data source pointers, namely the template grid and the local grid; when multiple instances reference the same part, they share the same template to avoid data copying; S1.2 Global Node Renumbering: Traverse each scope in the order of template grid first, then local grid, assign a new global consecutive number starting from 1 to each node, and at the same time establish a hash mapping table from scope information and old node ID to new node ID; S1.3 Output Node Segment: Write the renumbered nodes into the node segment of the COT file according to the new global numbering order.

3. The general finite element model conversion method according to claim 1, characterized in that: Step S2 specifically includes the following processes: S2.

1. Traverse all output scopes formed after the hierarchical flattening in step S1, and collect the basic description information of each unit. The basic description information includes the scope identifier, old number, unit type and node list. S2.2, Bucketing Phase: Using the unit type enumeration as the key, all units are divided into the corresponding type buckets; S2.3 Numbering Phase: The cells in each type of bucket are numbered independently starting from 1. At the same time, the old IDs in the node list are converted into new global IDs through the node mapping table produced in S1. S2.4 Mapping Construction: Establish a mapping relationship for each cell from its scope identifier and old number to the cell type enumeration and type local number, and generate a cell mapping table; S2.5 Output Stage: Each type of output is an independent segment in the COT file, i.e., a generation type segment. The segment header information of the independent segment includes the segment name and the number of segments.

4. The general finite element model conversion method according to claim 1, characterized in that: Step S3 details The process includes the following: S3.1 Material Attribute Collection: Collect all attribute blocks belonging to the same material, using the material name as the key; S3.2 Parameter Standardization: Write the parameters in different keywords into standardized material records according to a unified field; S3.3 Constitutive Type Determination: Execute the priority determination chain algorithm on the standardized material record to determine the constitutive type and generate a classification code; S3.4 Numbering and Output Fixation: Assign a unique material number to each standardized material, output a compact material record, establish a mapping relationship between material name and material number, and generate a material mapping table.

5. The general finite element model conversion method according to claim 1, characterized in that: Step S4 specifically includes the following processes: S4.1 Material Association: For the section definition associated with each element set, the material number is looked up in the material mapping table generated in step S3 by the material name; S4.2 Control Parameter Association: For the control parameters associated with each section, extract the hourglass control mode and distortion control flag; S4.3 Shell Thickness Association: Establish a thickness index table for the thickness values ​​in the shell section definition, and establish a mapping from elements to the thickness index; S4.4 Output format: Write the node number, material number, control parameters and thickness index into the unit record with a fixed format.

6. The general finite element model conversion method according to claim 1, characterized in that: Step S5 details The process includes the following: S5.1 Set Recursive Expansion: Recursively parse the cell set names in the input file into a list of old cell IDs; S5.2 Type Lookup and ID Conversion: For each old unit ID after expansion in step S5.1, look up its type enumeration and type local ID through the mapping table in S2; S5.3, Face Node Mapping: Based on the element type and face label, determine the face definition from the predefined face node definition table; the face node definition table defines the mapping relationship from face number to node local index for each supported element type; S5.4 Surface Segment Record Output: Write the surface segment information into the surface segment table of COT. The surface segment information includes the surface segment number, element type code, type local number, and surface number. S5.5 Surface Index Construction: Map each surface name to its surface object record number in the output to generate a surface index.

7. The general finite element model conversion method according to claim 1, characterized in that: Step S6 specifically includes the following processes: S6.1 THF Extraction: If the load references an amplitude definition, the existing THF is reused; otherwise, a default THF is created. S6.2 LoadOBJ Generation: Combine the loading method of the load with the THF number. The loading method includes the type code, degree of freedom direction and reference amplitude. S6.3 LoadDisp expansion: Expand the load's target object into a record-by-record using the node mapping table generated in step S1 and / or the surface index generated in step S5. The target object is a set of nodes or a surface name.

Images