A method, system and device for constructing CAE software

Abstract

This application belongs to the field of software simulation, and specifically discloses a method, system, and device for constructing a CAE software. The method includes: determining the simulation scenarios that the current version of the CAE software needs to support to determine the functions it needs to support; determining multiple sub-function modules that need to be added to the CAE software according to the functions to be supported; constructing at least one of the multiple sub-function modules using a data-oriented software design architecture; when all the multiple sub-function modules are constructed, completing the iteration of the current version of the CAE software to obtain an updated version of the CAE software; the updated version of the CAE software supports the above-mentioned simulation scenarios. Through this application, the problems of software complexity and performance caused by the coupling of multiple functional modules in the CAE software architecture are solved, thereby improving the development efficiency of the CAE software, enhancing software quality and execution performance, and improving the simulation experience of users.

Description

Technical Field

[0001] This application belongs to the field of software simulation. More specifically, it relates to a method, system, and device for constructing a CAE software. Background Art

[0002] In modern engineering design and analysis, Computer Aided Engineering (CAE) software plays a crucial role. Through Finite Element Analysis (FEA) technology, CAE software helps engineers simulate complex structures and materials, predicting their behaviors under different loads and boundary conditions. This method can effectively reduce experimental costs, accelerate the product development cycle, and improve the accuracy and reliability of design.

[0003] CAE software is widely used in multiple industries such as aerospace, automotive, civil engineering, and electronics. Each industry has its specific requirements and standards. These requirements and standards often cover various analysis types, including structural analysis, thermal analysis, fluid mechanics analysis, electromagnetic field analysis, etc. The requirements and constraints for different analysis types are different. The required data processing and management requirements are also different, involving a large amount of input data (such as geometric models, material properties) and output data (such as stress, displacement). It is required that the software can efficiently process and store these data, and at the same time support multiple standardized input and output file formats to maintain good compatibility. The users of CAE software are also diverse, including engineers, designers, researchers, etc. Different roles have different requirements for functions and interfaces. They need to customize models, boundary conditions, and analysis settings according to specific project requirements, increasing the complexity of requirements.

[0004] The architecture design of CAE software is a complex process that needs to comprehensively consider multiple factors such as multi-level architecture, modular design, performance optimization, user requirements, and technology selection. The design team needs to find a balance among these complexities to ensure the functionality, scalability, and maintainability of the final product. Through reasonable architecture design, a solid foundation can be laid for the successful development of CAE software, as well as the quality and usability of CAE software.

[0005] Traditional software design concepts usually design the overall architecture of software based on the ideas of Object-Oriented Design (OOD) or Object-Oriented Programming (OOP). This is in line with people's cognitive habits: everything in the world has its own attributes (including commonalities and characteristics) and behaviors, and their respective behaviors interact and change their attributes. When dealing with complex problems, various factors of the actual problem will naturally be abstracted into models of different categories, encapsulating their commonalities and characteristics, defining their behaviors, and then hierarchically and modularly subdividing the details of the entire requirement. In the design of CAE software, models, materials, assemblies, loads, boundary conditions, mesh elements, etc. will naturally be abstracted into individual classes, such as model classes, material classes, load classes, mesh element classes, etc. Then, their instances will be associated, combined, or aggregated with each other. For example, an assembly contains model objects and material properties, and a load instance holds a reference to the assembly on which it acts. The preprocessing stage creates and manages these instances and their associations, and then packages them into a structured data file for the solver to process, outputs it to the solver for solution, and gives the solved result file to the postprocessing module. The postprocessing module processes the result file and presents it on the view for the user to view and operate on the results.

[0006] The characteristics of this traditional CAE software architecture design are as follows: The model, solver, and postprocessing module in traditional finite element software are often highly coupled, resulting in poor flexibility and scalability of the system. Using class inheritance to implement different types of elements and material models increases the complexity of the code, leading to difficulties in maintenance and extension. Due to the tight combination of data and logic and the side effects of OOD / OOP, the traditional architecture may experience performance bottlenecks when dealing with a large number of nodes, especially in the case of dynamic analysis or complex models. Due to the complexity of the architecture, users may face a high learning curve and operational complexity when defining models and setting analysis parameters. Summary of the Invention

[0007] Aiming at the defects of the prior art, the purpose of this application is to provide a CAE software construction method, system, and device, aiming to solve the problem that the model, solver, and postprocessing module in traditional CAE software are often highly coupled, resulting in poor flexibility and scalability of the system.

[0008] To achieve the above purpose, in the first aspect, this application provides a CAE software construction method, including:

[0009] Determine the simulation scenarios that the current version of the CAE software needs to support to determine the functions it needs to support;

[0010] Determine multiple sub-function modules that need to be added to the CAE software according to the functions that need to be supported;

[0011] At least one of the multiple sub-functional modules is constructed by adopting a software design architecture oriented to data (Data Oriented Design, DOD).

[0012] After all the multiple sub-functional modules are constructed, the iteration of the current version of the CAE software is completed to obtain an updated version of the CAE software; the updated version of the CAE software supports the simulation scenario.

[0013] This application develops CAE software through a software design architecture oriented to data. In this architecture, entities generally have no inheritance or sibling relationships. The difference between entities in different sub-modules is only the different unique identifier ids and different data components in the container. This difference avoids the complex inheritance reference relationships in OOD / OOP and also simplifies the data structure, facilitating subsequent iteration and expansion of new business entities.

[0014] In a possible implementation manner, the multiple sub-functional modules include:

[0015] A file import sub-module, a model sub-module, a material sub-module, an assembly sub-module, a mesh division sub-module, a predefined field sub-module, a load sub-module, an interaction sub-module, a boundary condition sub-module, a constraint sub-module, an analysis step sub-module, an analysis output sub-module, and a job sub-module belonging to the pre-processing module;

[0016] A solution input processing sub-module, a solver call sub-module, and a solution result processing sub-module belonging to the solver module;

[0017] A solution result parsing sub-module, a solution result rendering sub-module, and a solution result operation sub-module belonging to the post-processing module.

[0018] In a possible implementation manner, the software design architecture oriented to data includes: entities, components, and systems; specifically including: constructing each unit corresponding to the sub-functional module into an entity, constructing each characteristic of the unit into a component, and using the system to maintain the data in the component; loading the components corresponding to the characteristics of each unit into the container of the corresponding entity; the component is used to carry the data corresponding to the characteristic, and the system is a pure function, and the object of the system is the component in the entity, and is used to perform logical processing on the data carried by the component to update the data.

[0019] In a possible implementation manner, when constructing a sub-functional module by adopting a software design architecture oriented to data, it includes:

[0020] Regarding each file record to be constructed by the file import module as an entity;

[0021] Take the models to be imported by the file import module and the models to be created by the model sub-module as entities;

[0022] Take the material types created by the material sub-module for the simulation scenario, the material types included in the models imported by the file import sub-module, and the material types included in the models created by the model sub-module as entities;

[0023] Take each assembly in the assembly sub-module as an entity;

[0024] Take each cell divided by the mesh division sub-module as an entity;

[0025] Take each predefined field data entry managed by the predefined field sub-module as an entity;

[0026] Take each load data entry managed by the load sub-module as an entity;

[0027] Take each boundary condition data entry managed by the boundary condition sub-module as an entity;

[0028] Take each interaction data entry managed by the interaction sub-module as an entity;

[0029] Take each constraint data entry created by the constraint sub-module as an entity;

[0030] Take each analysis step data entry created by the analysis step sub-module as an entity;

[0031] Take each analysis output data entry created by the analysis output sub-module as an entity;

[0032] Take each job data entry created by the job sub-module as an entity;

[0033] Take each node data parsed in the solution input sub-module as an entity;

[0034] Take each node data in the structured input data passed by the solver call sub-module to the solver as an entity;

[0035] Take the calculation result of each node obtained by the solution result processing sub-module from the solver output as an entity;

[0036] The solution result parsing sub-module, the solution result rendering sub-module, and the solution result operation sub-module take the data on each node obtained after parsing the solver output data as an entity.

[0037] In a possible implementation, construct each characteristic corresponding to each entity into a component;

[0038] The entity corresponding to the said file may include: a file type component, a file parsing result component;

[0039] The entity corresponding to the said model may include: a component set component, a region set component, a material set component, and an assembly information set component;

[0040] The entity corresponding to the said material type may include: an elastic component, a plastic component, a heat conduction component, a conductivity component, and a density component;

[0041] The entity corresponding to the said assembly may include: a component set component, a region set component, a geometric data component, a material data component, and an assembly information component;

[0042] The entity corresponding to the said cell may include: a cell type component, a cell ID component, and a cell geometric information component;

[0043] The said load data entry entity, interaction data entry entity, boundary condition data entity, constraint data entry entity, predefined field data entry entity may include: a region geometric information component, an amplitude characteristic component, and a physical quantity type component;

[0044] The said analysis step data entry entity may include: a calculation interval component, an iteration number constraint component, and an analysis type component;

[0045] The said job data entry entity may include: an assembly information component, a mesh generation information component, an analysis step information component, an input information component, and an output information component;

[0046] The data entity at each node during the solver input and output may contain: a temperature component, a stress component, and other target physical field components.

[0047] In a possible implementation, the behaviors of the data contained in the components of each module are constructed into a system, including:

[0048] For the file import sub-module, the object of the system is FileSystem. FileSystem is used to process file entities. The responsibility of FileSystem is to perform business logic on file entities, process the data attached to the components in the file entities, and update the processed data into the components. When the file type attached to the file type component in the file entity can be supported by FileSystem, FileSystem parses the supported file type and updates the parsing result into the data of the parsing component attached to the file entity. When a new file format needs to be supported, a new file type component is created and supported in FileSystem;

[0049] For the model sub-module, the object of the system is ModelSystem, and ModelSystem processes the data processes of model import and creation;

[0050] For the material sub-module, the object of the system is MaterialSystem, and MaterialSystem processes the data behaviors of various material entities;

[0051] For the assembly sub-module, the object of the system is AssemblySystem, and AssemblySystem processes the association logic between models and materials;

[0052] For the mesh cell sub-module, the object of the system is MeshSystem, and MeshSystem updates the component data after the division of mesh cell entities;

[0053] For the analysis step sub-module, the object of the system is StepSystem, and StepSystem manages the analysis step data entry entities and the update of their component data;

[0054] For the load sub-module, the object of the system is LoadSystem, and LoadSystem manages the load data entry entities and the update of their component data;

[0055] For the boundary condition sub-module, the object of the system is BoundaryConditionSystem, and BoundaryConditionSystem manages the boundary condition data entry entities and the update of their component data;

[0056] For the predefined field sub-module, the object of the system is PredefinedFielSystem, and PredefinedFielSystem manages the predefined field data entry entities and the update of their component data;

[0057] For the interaction sub-module, the object of the system is InteractionSystem, and InteractionSystem manages the interaction data entry entities and the update of component data;

[0058] For the constraint sub-module, the object of the system is ConstraintsSystem, and ConstraintsSystem manages the constraint data entry entities and the update of their component data;

[0059] For the analysis output sub-module, the object of the system is AnalysisSystem, and AnalysisSystem manages the analysis output data entry entity and the update of its component data;

[0060] For the job sub-module, the object of the system is JobSystem, and JobSystem manages the job data entry entity and the update of its component data.

[0061] In a possible implementation, when constructing the material sub-module using a data-oriented software architecture, it includes:

[0062] Determine the model to be constructed; the model includes at least one component, and each component includes at least one region; each region has a preset shape and material type;

[0063] Take each material type as an entity, and take each feature of any material type as a component; the component is used to carry the data corresponding to the feature; the feature includes at least one of the following: plasticity, linear elasticity, density component, and temperature;

[0064] Load the corresponding components into the container in the entity according to the model of the object, and use the system to maintain the data in each component.

[0065] In a possible implementation, when constructing the sub-function module using a data-oriented development method, it further includes:

[0066] The preprocessing module is used to process the entity and the data contained in the entity managed by the system of each sub-function module it contains, and output the processed data in the format required by the solver module;

[0067] The solver module is used to create the entities of each sub-function module during the solution process according to the data output by the preprocessing module, and attach the data types required by the solver to the entities, and then the system of each sub-function module processes the created entities and the data contained in their components, and obtains the solution result based on the finite element analysis algorithm, and outputs the solution result in the format required by the postprocessing module;

[0068] The postprocessing module is used to read the solution result, create the actual postprocessing entities and related component data of each of its sub-function modules, and then render and present the result on the postprocessing view, and respond to the user's viewing operation.

[0069] In a second aspect, the present application provides a CAE software construction system, including:

[0070] A simulation scenario determination module, which is used to determine the simulation scenarios that the current version of the CAE software needs to support, so as to determine the functions it needs to support;

[0071] A CAE software building module, configured to determine multiple sub - function modules to be added to the CAE software according to the functions to be supported; and construct at least one of the multiple sub - function modules by adopting a data - oriented software design architecture; after all the multiple sub - function modules are constructed, complete the iteration of the current version of the CAE software to obtain an updated version of the CAE software; the updated version of the CAE software supports the simulation scenario.

[0072] In a third aspect, the present application provides an electronic device, including: at least one memory for storing programs; at least one processor for executing the programs stored in the memory, and when the programs stored in the memory are executed, the processor is configured to execute the method described in the first aspect or any one of the possible implementation manners of the first aspect.

[0073] In a fourth aspect, the present application provides a computer - readable storage medium storing a computer program, and when the computer program runs on a processor, the processor is caused to execute the method described in the first aspect or any one of the possible implementation manners of the first aspect.

[0074] In a fifth aspect, the present application provides a computer program product, and when the computer program product runs on a processor, the processor is caused to execute the method described in the first aspect or any one of the possible implementation manners of the first aspect.

[0075] It can be understood that the beneficial effects of the above - mentioned second aspect to the fifth aspect can refer to the relevant descriptions in the first aspect, and will not be elaborated here.

[0076] Generally speaking, compared with the prior art, the above - mentioned technical solution conceived by the present application has the following beneficial effects:

[0077] This application provides a method, system, and device for constructing a CAE software. The CAE software is developed through a data-oriented DOD software design architecture of entity-component-system. In this architecture, each entity has a different unique identifier (id) and a container containing different components, and there is no other data. The file entities, material entities, etc. in this application are only entities identified and established by different sub-functional modules. They are all of the same entity class in terms of data type, not different types of entities. Except for the different ids and the components contained in the containers, the entities have no other information, and there is no concept of category. This is the most fundamental difference from OOD / OOP, that is, entities generally do not have inheritance or sibling relationships. The difference between entities in different sub-modules is only the different unique identifier (id) and the different data components in the container. This difference avoids the complex inheritance reference relationships in OOD / OOP, simplifies the data structure, facilitates subsequent iterative expansion of new business entities, is more friendly to memory and CPU caches, and at the same time avoids the problem of multi-threaded data synchronization caused by complex reference inheritance, and is friendly to multi-threaded parallel computing. BRIEF DESCRIPTION OF THE DRAWINGS

[0078] Figure 1 is a schematic flowchart of a method for constructing a CAE software provided by an embodiment of this application;

[0079] Figure 2 is an architecture diagram of a system for constructing a CAE software provided by an embodiment of this application;

[0080] Figure 3 is a schematic structural diagram of an electronic device provided by an embodiment of this application. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0081] In order to make the objectives, technical solutions, and advantages of this application clearer and more understandable, the following further details this application in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain this application and are not used to limit this application.

[0082] As used herein, the term "and / or" describes the association relationship of associated objects and indicates that there can be three relationships. For example, A and / or B can represent: A exists alone, A and B exist simultaneously, and B exists alone. The symbol " / " in this article represents an "or" relationship between associated objects. For example, A / B represents A or B.

[0083] In the embodiments of the present application, words such as "exemplary" or "for example" are used to represent examples, illustrations or explanations. Any embodiment or design solution described as "exemplary" or "for example" in the embodiments of the present application should not be construed as being more preferred or having more advantages than other embodiments or design solutions. Rather, the use of words such as "exemplary" or "for example" is intended to present relevant concepts in a specific manner.

[0084] The embodiments of the present application will be described below with reference to the accompanying drawings in the embodiments of the present application.

[0085] It should be noted that precisely because of the broad application fields of CAE software, the complex and professional problems it solves, combined with the diversity of users and the compatibility requirements of the industry ecosystem, these factors will inevitably bring complexity to the design and implementation of CAE software, which is mainly reflected in:

[0086] 1. At the hierarchical architecture level, the user interface layer, application logic layer, data access layer, and computing layer need to be considered to ensure that these layers can meet the efficient, easy-to-use, and extensible domain functions they handle respectively. At the same time, it is necessary to ensure effective communication and collaboration between the layers.

[0087] 2. Based on the general process of simulation analysis, the software usually needs to be divided into various functional modules, such as pre-processing modules, solvers, post-processing, etc. Each module can be further divided into smaller sub-modules. For example, the pre-processing module can be divided into sub-modules such as model creation and import support, material property setting, assembly, boundary condition and load and interaction application, mesh generation, analysis type step, etc. The solver has explicit and implicit analysis solvers, static, dynamic, fluid solvers, and other sub-modules. The design of these modules should ensure loose coupling between the modules, so as to facilitate independent development, maintenance, and combined use to solve specific analysis problems. High coupling between modules will lead to reduced system flexibility and increased maintenance costs. For example, modifying a certain module will affect the functions of other modules, resulting in unreliable development, testing, maintenance costs, and final functions.

[0088] 3. In addition to the problems caused by the coupling between software modules, the analyzed problems often have coupling in the characteristics of the analysis model, such as multi-physics field coupling. A specific analysis problem involves the coupling of multiple physical fields (such as heat, structure, fluid, etc.). When designing the architecture, it is necessary to consider how to effectively handle these coupling relationships. At the same time, the solution methods and algorithms of different physical fields may be different. The architecture design needs to consider how to integrate these algorithms to ensure the accuracy and stability of the calculation, and make corresponding matching adjustments in the front view responsible for input and the post-processing responsible for output.

[0089] Therefore, by way of example, Figure 1 is a flowchart of a method for constructing a CAE software provided by the embodiments of the present application, asFigure 1 As shown in the figure, it includes the following steps:

[0090] Step S101: Determine the simulation scenarios that the current version of the CAE software needs to support to determine the functions it needs to support;

[0091] Step S102: Determine multiple sub - function modules that need to be added to the CAE software according to the functions to be supported;

[0092] Step S103: Build at least one of the multiple sub - function modules using a data - oriented software design architecture;

[0093] Step S104: When all the multiple sub - function modules are built, complete the iteration of the current version of the CAE software to obtain an updated version of the CAE software; the updated version of the CAE software supports the simulation scenarios.

[0094] In a possible implementation, the multiple sub - function modules include:

[0095] A file import sub - module, a model sub - module, a material sub - module, an assembly sub - module, a mesh generation sub - module, a predefined field sub - module, a load sub - module, an interaction sub - module, a boundary condition sub - module, a constraint sub - module, an analysis step sub - module, an analysis output sub - module, and a job sub - module belonging to the pre - processing module;

[0096] A solution input processing sub - module, a solver call sub - module, and a solution result processing sub - module belonging to the solver module;

[0097] A solution result parsing sub - module, a solution result rendering sub - module, and a solution result operation sub - module belonging to the post - processing module.

[0098] In a possible implementation, the data - oriented software design architecture includes: entities, components, and systems; specifically: build each unit corresponding to a sub - function module into an entity, build each characteristic of the unit into a component, use the system to maintain the data in the component; load the components corresponding to the characteristics of each unit into the container of the corresponding entity; the component is used to carry the data corresponding to the characteristic, and the system is a pure function, and the object of the system is the component in the entity, which is used to perform logical processing on the data carried by the component to update the data.

[0099] It can be understood that the data - oriented software architecture design is an entity - component - system architecture, which can be abbreviated as the (Entity - Component - System, ECS) architecture.

[0100] In a possible implementation, when building a sub - function module using a data - oriented software design architecture, it includes:

[0101] Each file record to be imported into the file import module is taken as an entity;

[0102] The models to be imported by the file import module and the models to be created by the model sub-modules are taken as entities;

[0103] The material types created by the material sub-module for the simulation scenario, the material types included in the models imported by the file import sub-module, and the material types included in the models created by the model sub-module are taken as entities;

[0104] Each assembly in the assembly sub-module is taken as an entity;

[0105] Each cell divided by the mesh division sub-module is taken as an entity;

[0106] Each predefined field data entry managed by the predefined field sub-module is taken as an entity;

[0107] Each load data entry managed by the load sub-module is taken as an entity;

[0108] Each boundary condition data entry managed by the boundary condition sub-module is taken as an entity;

[0109] Each interaction data entry managed by the interaction sub-module is taken as an entity;

[0110] Each constraint data entry created by the constraint sub-module is taken as an entity;

[0111] Each analysis step data entry created by the analysis step sub-module is taken as an entity;

[0112] Each analysis output data entry created by the analysis output sub-module is taken as an entity;

[0113] Each job data entry created by the job sub-module is taken as an entity;

[0114] Each node data parsed in the solution input sub-module is taken as an entity;

[0115] Each node data in the structured input data passed by the solver call sub-module to the solver is taken as an entity;

[0116] The calculation results of each node obtained by the solution result processing sub-module from the solver output are taken as an entity;

[0117] The solution result parsing sub-module, the solution result rendering sub-module, and the solution result operation sub-module take the data on each node obtained after parsing the solver output data as an entity.

[0118] It should be noted that in the pre - processing stage of CAE software, the model to be studied is divided into many grid cells. Each grid cell is a geometric body in the shape of a tetrahedron (with four vertices and four triangular faces, similar to a triangular pyramid) or a hexahedron (similar to a cube), etc. The input material properties, loads, predefined fields, and boundary condition data are dispersed into these grid cells. The vertices, face centers, or body centers of these grid cells are nodes. Based on the distribution characteristics of the quantities at these nodes, the quantities at each position on the entire grid cell can be obtained. Through the nodes on a large number of grid cells in pre - processing, solution, and post - processing, the physical quantities on the entire model are dispersed into the quantity values at these nodes, and then the data at these nodes are processed or calculated.

[0119] In a possible implementation, each characteristic corresponding to each entity is constructed into a component.

[0120] The entity corresponding to the file may include: a file type component, a file parsing result component.

[0121] The entity corresponding to the model may include: a component set component, a region set component, a material set component, and an assembly information set component.

[0122] The entity corresponding to the material type may include: an elasticity component, a plasticity component, a heat conduction component, an electrical conductivity component, and a density component.

[0123] The entity corresponding to the assembly may include: a component set component, a region set component, a geometric data component, a material data component, and an assembly information component.

[0124] The entity corresponding to the cell may include: a cell type component, a cell ID component, and a cell geometric information component.

[0125] The entity of the load data entry, interaction data entry, boundary condition data, constraint data entry, predefined field data entry may include: a region geometric information component, an amplitude characteristic component, and a physical quantity type component.

[0126] The entity of the analysis step data entry may include: a calculation interval component, an iteration number constraint component, and an analysis type component.

[0127] The entity of the job data entry may include: an assembly information component, a mesh generation information component, an analysis step information component, an input information component, and an output information component.

[0128] The data entity at each node in the input - output process of the solver may include: a temperature component, a stress component, and other target physical field components.

[0129] In a possible implementation, the behaviors of the data contained in the components of each module are constructed into a system, including:

[0130] For the file import sub-module, the object of the system is FileSystem. FileSystem is used to process file entities. The responsibility of FileSystem is to perform business logic on file entities, process the data attached to the components in the file entities, and update the processed data to the components. When the file type attached to the file type component of the file entity can be supported by FileSystem, FileSystem parses the supported file type and updates the parsing result to the data of the parsing component attached to the file entity; when a new file format needs to be supported, a new file type component is created and support is provided in FileSystem;

[0131] For the model sub-module, the object of the system is ModelSystem, and ModelSystem processes the data process of model import and creation;

[0132] For the material sub-module, the object of the system is MaterialSystem, and MaterialSystem processes the data behaviors of various material entities;

[0133] For the assembly sub-module, the object of the system is AssemblySystem, and AssemblySystem processes the association logic between models and materials;

[0134] For the mesh cell sub-module, the object of the system is MeshSystem, and MeshSystem realizes the update of the component data after the division of the mesh cell entity;

[0135] For the analysis step sub-module, the object of the system is StepSystem, and StepSystem manages the analysis step data entry entity and the update of its component data;

[0136] For the load sub-module, the object of the system is LoadSystem, and LoadSystem manages the load data entry entity and the update of its component data;

[0137] For the boundary condition sub-module, the object of the system is BoundaryConditionSystem, and BoundaryConditionSystem manages the boundary condition data entry entity and the update of its component data;

[0138] For the predefined field sub-module, the object of the system is PredefinedFielSystem, and PredefinedFielSystem manages the update of predefined field data entry entities and their component data;

[0139] For the interaction sub-module, the object of the system is InteractionSystem, and InteractionSystem manages the update of interaction data entry entities and component data;

[0140] For the constraint sub-module, the object of the system is ConstraintsSystem, and ConstraintsSystem manages the update of constraint data entry entities and their component data;

[0141] For the analysis output sub-module, the object of the system is AnalysisSystem, and AnalysisSystem manages the update of analysis output data entry entities and their component data;

[0142] For the job sub-module, the object of the system is JobSystem, and JobSystem manages the update of job data entry entities and their component data.

[0143] In a possible implementation, when constructing the material sub-module using a data-oriented software architecture, it includes:

[0144] Determine the model to be constructed; the model includes at least one component, and each component includes at least one region; each region has a preset shape and material type;

[0145] Take each material type as an entity, and take each feature of any material type as a component; the component is used to carry the data corresponding to the feature; the features include at least one of the following: plasticity, linear elasticity, density component, and temperature;

[0146] Load the corresponding components into the container in the entity according to the model of the object, and use the system to maintain the data in each component.

[0147] In a possible implementation, when constructing the sub-function module using a data-oriented development method, it further includes:

[0148] The preprocessing module is used to process the entities and the data contained in the entities managed by the system of each sub-function module it contains, and output the processed data in the format required by the solver module;

[0149] The solver module is used to create entities of each sub - function module during the solution process according to the data output by the pre - processing module, and attach the data types required by the solver to the entities. Then, the system processes the created entities of each sub - function module and the data contained in their components, obtains the solution result based on the finite - element analysis algorithm, and outputs the solution result in the format required by the post - processing module.

[0150] The post - processing module is used to read the solution result, create actual post - processing entities of each of its sub - function modules and related component data, and then render and present the result on the post - processing view and respond to the user's viewing operation.

[0151] In summary, the present application provides a method for constructing a CAE software. The specific steps may include: conducting a requirements analysis based on the simulation scenarios that the CAE software is to support to determine the simulation requirements; determining the functional details that the current iterative version of the CAE software is to support based on the simulation requirements; designing the interaction (User Experience, UE) and interface (User Interface, UI) of the CAE software based on the functional details; decomposing the software functions into each sub - function module through a general design based on the UE and UI design; designing the detailed design of each sub - function module using the ECS architecture based on the sub - function module division; implementing the functions of each sub - module through coding using the ECS architecture based on the detailed design of each sub - function module; combining the functions of each sub - function module using the ECS architecture to implement the overall functional process; releasing a test version based on the implementation of the functional process and conducting verification tests on the simulation scenarios; adjusting and improving the officially released version of the CAE software after this iteration based on the verification test process.

[0152] Furthermore, the innovation of the present application lies in that, in view of the complexity of the requirements and the high performance requirements of the CAE software, the ECS architecture is adopted in the detailed design and coding implementation of the functional sub - modules of the software and in the integration of the functions of the entire new - function integration sub - modules. This architecture is described as follows:

[0153] The ECS software architecture is the Entity-Component-System. The ECS architecture is a data-oriented software design architecture. Its core idea is to completely separate data (components) from behavior (systems), and define the behavior and attributes of the research object through composition rather than inheritance. Entity-Component-System is easily misunderstood as a system composed of entities and components. In fact, entities, components, and systems are at the same level, and their definitions and responsibilities are as follows: Entity: Represents a "unit" that can mount several components and can be understood as a component container with an id. Component: A specific piece of data mounted on an Entity, carrying the attributes of a certain part of the entity, which is a pure data structure without functions. That is, it only contains a specific data attribute without behavior. System: A pure function without data, only concerned with Entities with certain specific attributes (components), performs logical processing on the data in the components, and updates the processed data in the components. Scene (also called world in some places), corresponding to the actual problem solved by this architecture, is uniformly called Scene below. It is also a concept implicit in the ECS architecture.

[0154] In the ECS architecture, the relationship among the above four is as follows: The scene is responsible for organizing and managing various systems and entities. Entities contain different components, and each category of components only contains pure data of a specific type. A single system is only responsible for updating the data in a single type of component, which is the behavior corresponding to these data. Different systems and entities organize interactions and logic in the scene to solve problems.

[0155] Through this application, based on the ECS architecture used in this construction method, we can efficiently design and develop CAE software, greatly improving the code reusability and scalability of CAE software projects as well as the software performance improvement brought by this architecture, thereby efficiently and continuously expanding the functions and optimizing the performance of the software.

[0156] In a more specific embodiment, a method for constructing a CAE software provided in this embodiment includes the following steps:

[0157] Step 1.1, determine the simulation scene that the current version of the CAE software needs to support:

[0158] The CAE software version here can be the initial version starting from scratch or the development of a new version based on an existing version. Here, it is collectively referred to as the current version, that is, the software version to be produced corresponding to the current iteration (whether it is the initial version iteration or subsequent version iterations), which does not affect the subsequent steps.

[0159] Based on the iterative rhythm, project cycle, and project resources, the current iteration of the version usually focuses on implementing support for a certain type of simulation requirements. For example, assume that the previous version of the CAE software already supports static analysis (which can solve static analysis scenarios, such as the structural strength analysis of bridges, the load-bearing analysis of walls and columns, the fatigue analysis of screws, etc.). The current version needs to support collision scenarios (such as the drop test of chip devices, the car crash test, etc.). Then the scenario type that the current CAE software needs to support is the dynamic analysis type of scenarios. The actual scenarios supported by the iteration include but are not limited to the above example. The actual scenarios are very extensive, including a large number of scenarios classified by force, heat, electromagnetism, fluid, and their coupling scenarios, etc. The above example is only used to illustrate the relationship between the iterative version of the CAE software and the simulation scenarios.

[0160] Step 1.2, based on the simulation scenario determined in the previous step 1.1, determine what functions need to be implemented to support the analysis of this simulation scenario, and then clarify the main functions that the current iterative software version needs to support, so as to conduct specific requirements analysis.

[0161] Step 1.3, based on the functional requirements analysis in step 1.2, conduct UE and UI design to determine the interaction process details and interface details of the new functions in the software version.

[0162] Step 1.4, based on the UE / UI design in step 1.3, determine the functional details that each functional module and sub-functional module need to support. Usually, the functional modules of CAE are divided as follows:

[0163] The preprocessing can be divided into functional sub-modules: file import sub-module, model sub-module, material sub-module, assembly sub-module, mesh generation sub-module, predefined field sub-module, load sub-module, interaction sub-module, boundary condition sub-module, constraint sub-module, analysis step sub-module, analysis output sub-module, job sub-module, etc.

[0164] The solver module can be divided into functional sub-modules: solver input processing sub-module, solver call sub-module, solver result processing sub-module.

[0165] The post-processing module is divided into functional sub-modules: solver result parsing sub-module, solver result rendering sub-module, solver result operation sub-module.

[0166] According to the requirement details in step 1.2 and the UE / UI details in step 1.3, the newly added functions generally involve the preprocessing, solver, and post-processing modules, and involve the functions of one or more sub-modules below each of them. We will conduct a general design for each sub-functional module involved to determine the functional details (new addition or change of functions) that each sub-module needs to support. This general design in this step is equivalent to the refinement of the functions and requirements of each sub-module.

[0167] Taking the material module as an example, the usual scenario is that the user imports or creates an object model Model to be analyzed in the simulation software. This model has one or more parts, and each part has one or more sections. Each section contains a specific geometric shape and material type. For example, when studying a car crash test, the user imports a car model Model-Car. The wheels of the car are one of the parts, which we call part-wheel-A (assuming A corresponds to the left front wheel). And this part of the wheel can be divided into two sections: the tire and the wheel hub, named section-A and section-B respectively. For the tire section-A, in the simulation software, a 3D geometric model of the tire shape needs to be drawn first, and then its material is specified as a certain rubber material. Similarly, section-B is assembled from a geometric model of the wheel hub shape and a material of a certain metal material. All other parts of the car are processed in this way. Finally, we get a car model in the simulation CAE software, including the geometric shapes and material types of various parts of the car.

[0168] So in this simulation analysis scenario, building the model of the car requires creating or importing the material properties of each part of the car, that is, managing dozens (possibly more) of materials that make up the car. This is the function that the material sub-module of the CAE software needs to support. Other simulation analysis scenarios, such as the thermal effect analysis of chips and the bridge load-bearing analysis, etc., all need to build geometric models and assemble material properties. The functions related to the material sub-module are all about creating, importing, and managing various materials that make up the analysis target.

[0169] Similar to other sub-function modules, based on simulation steps 1.1 to 1.3, refine the functional requirements of each sub-module. This process is the general design. This step does not involve specific software design, but is a functional division and refinement design.

[0170] Step 1.5, based on the general design in Step 1.4, conduct a detailed design for each sub-module with functional changes. In this process, the ECS (Entity-Component-System) architecture can be used to design the functions of each sub-module. The specific approach is as follows:

[0171] Step 1.5.1, identify and establish the entities of each sub-module: In the file import sub-module and the model sub-module, each file record is an entity; the models imported from files and the models created in each model sub-module are also entities; each material attached to the models created for the simulation scenario or imported from model files in the material module is an entity (however, various parameter data of the material will be abstracted as components in the next step); each assembly part in the assembly sub-module is also an entity; each cell after mesh generation can be regarded as an entity; each data record generated by the predefined field sub-module, load sub-module, boundary condition sub-module, constraint sub-module, analysis step sub-module, analysis output sub-module, and job sub-module is an entity. The data or file objects processed by the solver and post-processing module can be identified as entities in the same way, and no further elaboration will be provided here.

[0172] It can be seen that these entities in the ECS architecture all have different unique identifiers (ids) and containers containing different components, and there is no other data. The file entities and material entities mentioned here and below are only entities identified and established by different sub-functional modules. In terms of data type, they are all the same entity class, not different types of entities. Except for the different ids and the components contained in the containers, the entities have no other information, so there is no concept of category. This is the most fundamental difference from OOD / OOP, that is, entities generally do not have inheritance or sibling relationships. The difference between entities in different sub-modules is only the different unique identifiers (ids) and the different data components in the containers. This difference avoids the complex inheritance and reference relationships in OOD / OOP, simplifies the data structure, facilitates the subsequent iteration and expansion of new business entities, is more friendly to memory and CPU caches, and at the same time avoids the multi-threaded data synchronization problems caused by complex reference inheritance, and is friendly to multi-threaded parallel computing.

[0173] Step 1.5.2: Identify all entity-related data in the previous step 1.5.1, identify and create components for this data according to the data type, and then place the entity-related data in the form of component objects into the container of the entity. The component descriptions for each sub-module entity are as follows: The components of the file entity include the file type component (including the file path and file suffix), the file parsing result component, etc.; The entities of the model include the part set component, the section set component, the material set component, etc., and the assembly information set component, etc.; The material entity contains various components related to material properties, such as the elasticity component, the plasticity component, the heat conduction component, the conductivity component, the density component, etc. Different material entities contain one or several of these components, and the contained components record relevant parameters. For example, if a certain material contains a density component, then its container has a density component, and this component will record the density of the research target; The assembly part entity can contain components such as the part set component, the section set component, the geometric data component, the material data component, the assembly information component, etc.; The mesh cell entity can contain the cell type component, the cell id component, the cell geometric information component, etc.

[0174] It can also be seen here that each component contains only data of a specific data type and has no direct relationship with other components. The data of the component is also established with the entity through whether the container of the entity contains the component. This is also different from OOD / OOP. If an entity does not contain a certain component, then the data attached to that component will not exist in the data, and thus there is no related access overhead, avoiding the additional overhead of data types brought by OOD / OOP references.

[0175] Pre-defined field sub-module, load sub-module, boundary condition sub-module, constraint sub-module, analysis step sub-module, analysis output module, job module, solver, and each sub-module of the post-processing, etc. All these modules can create the data associated with or contained in their respective entities in the form of data components like this and then add them to the containers of the corresponding entities.

[0176] Step 1.5.3: Identify and create System objects in each sub-module. For example, the System object in the file import sub-module can be called FileSystem, which is used to process file entities. The responsibility of FileSystem is to perform business logic on file entities. Specifically, it processes the data attached to the components in the file entity and updates the processed data to these components. When the file type attached to the file type component in the file entity can be supported by FileSystem, FileSystem will parse this format and update the parsing result to the data of the parsing component attached to this file entity. When we want to support a new file format, we only need to create a new file type component and provide support in FileSystem, and this process will not affect the previously supported types and processing logic at all. If it were in OOD / OOP, we might have to modify the base class interface to utilize polymorphic features to achieve this effect, and the support logic for both the existing base class and the already implemented file formats would be affected to a certain extent. Therefore, the characteristic of these System objects in the ECS architecture to purely process data without concerning about the data itself is conducive to maintaining the stability and continuous expansion of functions.

[0177] In this way, we can design the System objects of other sub-modules: ModelSystem in the model sub-module processes the data process of model import and creation; MaterialSystem in the material sub-module processes the data behavior of various material entities; AssemblySystem in the assembly sub-module processes the association logic between models and materials; MeshSystem in the mesh cell sub-module realizes the update of the component data after the division of mesh cell entities; The design of the System in other functional modules is similar, providing behavior operations for the data in the components of the corresponding entities and updating the changed data to the components.

[0178] The behaviors of these System objects are triggered by UE operations on the interface in some cases, and automatically triggered by analysis steps in the simulation analysis process in other cases. Essentially, they all trigger the System to implement various functions to manage the data in the entities and the components contained in the entities.

[0179] Step 1.5.4: After the above sub-modules are designed in detail according to Steps 1.5.1, 1.5.2, and 1.5.3, one more step of design is required, that is, to process the data of the entities and systems of each sub-module in the scene, summarize their behaviors, handle the communication logic between modules, and exchange data to implement the logic of the final new function. Specifically, as follows:

[0180] Step 1.5.4.1, in the pre - processing scenario, manage the entities and the data contained in the entities of each pre - processing sub - module in the System, and organize them into the input data of the solver in the format required by the solver.

[0181] Step 1.5.4.2, in the solution scenario, according to the solution System, load the input data given by the pre - processing, create the entities in the solution process, and attach the data types required by the solver core to the entities. Then the solution System processes the entities and the data contained in their components, obtains the solution results based on the finite - element analysis algorithm, and outputs the solution results to the post - processing module according to the requirements of the post - processing.

[0182] Step 1.5.4.3, after receiving the results given by the solution module, the post - processing module enters the post - processing scenario. The System of the post - processing module reads the result data, creates the actual post - processing entities and related component data, and then renders and presents the results on the post - processing view to the user. Based on the user's operations, the user can view the spatial local or the results at a certain time point of the result data, or can also view the dynamic process within a period of time.

[0183] Step 1.6, based on the detailed design of each module in Step 1.5, code to implement the functions of each sub - module. Specifically, it is to code and create the classes of entities, various components, and systems, and then implement these responsibilities according to the responsibilities and behaviors assigned to each class in Step 1.5. Then organize the functions and interactions of these sub - modules in the scenarios of the pre - processing, solver, and post - processing modules, and present the results to the UI based on UE operations. The specific coding implementation process depends on the design and actual development iteration in the previous step, and those skilled in the art can further implement it with reference to the above examples, which will not be elaborated here.

[0184] Step 1.7, based on the coding implementation in Step 1.6, test the software behavior and release the test version, and then adjust the details of the software according to the experience of the testers and end - users and the problems encountered in the solution process to complete this round of iteration, and finally release the version of the current software iteration.

[0185] Figure 2 This is an architecture diagram of a CAE software construction system provided by an embodiment of the present application, as Figure 2 shown, including:

[0186] A simulation scenario determination module 210, used to determine the simulation scenarios that the current version of the CAE software needs to support, so as to determine the functions it needs to support;

[0187] The CAE software building module 220 is used to determine multiple sub - function modules that need to be added to the CAE software according to the functions to be supported; and build at least one of the multiple sub - function modules using a data - oriented software design architecture; after all the multiple sub - function modules are built, iterate the current version of the CAE software to obtain an updated version of the CAE software; the updated version of the CAE software supports the simulation scenario.

[0188] It should be understood that the above - mentioned system is used to execute the method in the above - mentioned embodiment. For the corresponding program modules in the system, their implementation principles and technical effects are similar to those described in the above - mentioned method. The working process of this system can refer to the corresponding process in the above - mentioned method, and will not be elaborated here.

[0189] Based on the method in the above - mentioned embodiment, an embodiment of the present application provides an electronic device, as Figure 3 shown. The electronic device may include: a processor 310, a communication interface 320, a memory 330, and a communication bus 340. Among them, the processor 310, the communication interface 320, and the memory 330 communicate with each other through the communication bus 340. The processor 310 can call the logical instructions in the memory 330 to execute the method in the above - mentioned embodiment.

[0190] In addition, when the logical instructions in the above - mentioned memory 330 are implemented in the form of software functional units and sold or used as an independent product, they can be stored in a computer - readable storage medium. Based on such an understanding, the technical solution of the present application, in essence, or the part that contributes to the prior art, or a part of this technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to enable a computer device (which can be a personal computer, a server, or a network device, etc.) to execute all or part of the steps of the method described in each embodiment of the present application.

[0191] Based on the method in the above - mentioned embodiment, an embodiment of the present application provides a computer - readable storage medium. The computer - readable storage medium stores a computer program. When the computer program runs on a processor, it enables the processor to execute the method in the above - mentioned embodiment.

[0192] Based on the method in the above - mentioned embodiment, an embodiment of the present application provides a computer program product. When the computer program product runs on a processor, it enables the processor to execute the method in the above - mentioned embodiment.

[0193] It can be understood that the processor in the embodiments of the present application may be a central processing unit (CPU), or may also be other general-purpose processors, digital signal processors (DSPs), application specific integrated circuits (ASICs), field programmable gate arrays (FPGAs), or other programmable logic devices, transistor logic devices, hardware components, or any combination thereof. The general-purpose processor may be a microprocessor or any conventional processor.

[0194] The method steps in the embodiments of the present application may be implemented in a hardware manner or by a processor executing software instructions. The software instructions may be composed of corresponding software modules, and the software modules may be stored in a random access memory (RAM), flash memory, read-only memory (ROM), programmable ROM (PROM), erasable PROM (EPROM), electrically erasable PROM (EEPROM), registers, hard disks, removable hard disks, CD-ROMs, or any other form of storage medium well known in the art. An exemplary storage medium is coupled to the processor so that the processor can read information from the storage medium and write information to the storage medium. Of course, the storage medium may also be a component of the processor. The processor and the storage medium may be located in the ASIC.

[0195] In the above embodiments, it can be implemented in whole or in part by software, hardware, firmware, or any combination thereof. When implemented using software, it can be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. When the computer program instructions are loaded and executed on a computer, the processes or functions described in the embodiments of the present application are generated in whole or in part. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable devices. The computer instructions can be stored in a computer-readable storage medium or transmitted through the computer-readable storage medium. The computer instructions can be transmitted from one website, computer, server, or data center to another website, computer, server, or data center by wire (such as coaxial cable, optical fiber, digital subscriber line (DSL)) or wirelessly (such as infrared, wireless, microwave, etc.). The computer-readable storage medium can be any available medium that can be accessed by a computer or a data storage device such as a server or a data center that includes one or more integrated available media. The available medium can be a magnetic medium (such as a floppy disk, a hard disk, a magnetic tape), an optical medium (such as a DVD), or a semiconductor medium (such as a solid state disk (SSD)), etc.

[0196] It can be understood that the various digital numbers involved in the embodiments of the present application are only for the convenience of description and are not used to limit the scope of the embodiments of the present application.

[0197] Those skilled in the art can easily understand that the above are only the preferred embodiments of the present application and are not intended to limit the present application. Any modifications, equivalent replacements, and improvements made within the spirit and principles of the present application shall be included in the protection scope of the present application.

Claims

1. A CAE software construction method, characterized in that: include: Determine the simulation scenarios that the current version of CAE software needs to support in order to determine the functions it needs to support; Designing the interaction and interface of the CAE software according to the functions to be supported, and determining a plurality of sub-function modules to be added to the CAE software based on the interaction and interface; At least one of the multiple sub-function modules is constructed using a data-oriented software design architecture; including: taking the file record to be constructed by the file import sub-module as an entity; taking the model to be imported by the file import sub-module and the model to be created by the model sub-module as an entity; taking the material type created by the material sub-module for the simulation scene, the material type included in the model imported by the file import sub-module, and the material type included in the model created by the model sub-module as an entity; taking the assembly in the assembly sub-module as an entity; taking the cell divided by the grid division sub-module as an entity; taking the predefined field data entry managed by the predefined field sub-module as an entity; taking the load data entry managed by the load sub-module as an entity; taking the boundary condition data entry managed by the boundary condition sub-module as an entity; body; the interaction data entries managed by the interaction submodule are taken as entities; the constraint data entries created by the constraint submodule are taken as entities; the analysis step data entries created by the analysis step submodule are taken as entities; the analysis output data entries created by the analysis output submodule are taken as entities; the job data entries created by the job submodule are taken as entities; the node data parsed in the solution input submodule are taken as entities; the node data in the structured input data passed to the solver by the solver call submodule are taken as entities; the calculation results of the nodes obtained from the solver output by the solution result processing submodule are taken as entities; the solution result parsing submodule, the solution result rendering submodule and the solution result operation submodule take the data on the nodes obtained after the solver output data is parsed as entities; When the construction of multiple sub-function modules is completed, the iteration of the current version of CAE software is completed to obtain an updated version of CAE software; the updated version of CAE software supports the simulation scenario.

2. The method according to claim 1, characterized in that: The multiple sub-function modules include: The pre-processing module includes a file import submodule, a model submodule, a material submodule, an assembly submodule, a meshing submodule, a predefined field submodule, a load submodule, an interaction submodule, a boundary condition submodule, a constraint submodule, an analysis step submodule, an analysis output submodule, and an operation submodule; A solution input processing submodule, a solver calling submodule, and a solution result processing submodule belonging to the solver module; The post-processing module includes the solution result parsing submodule, solution result rendering submodule and solution result operation submodule.

3. The method according to claim 2, characterized in that The data-oriented software design architecture includes: entities, components and systems; specifically includes: constructing each unit of the corresponding sub-functional module into an entity, constructing each characteristic of the unit into a component, and using the system to maintain the data in the component; loading the corresponding component into the container of the corresponding entity according to the characteristics of each unit; the component is used to carry the data corresponding to the characteristic, the system is a pure function, the object processed by the system is the component in the entity, and is used to perform logical processing on the data carried by the component to update the data.

4. The method according to claim 1, characterized in that: Build each characteristic corresponding to each entity into a component; The entity corresponding to the file includes: a file type component and a file parsing result component; The model corresponds to an entity including: a component set component, a region set component, a material set component and an assembly information set component; The material type corresponds to an entity, including: an elastic component, a plastic component, a thermal conductivity component, an electrical conductivity component, and a density component; The assembly corresponding entity includes: a component set component, a region set component, a geometry data component, a material data component and an assembly information component; The cell corresponding entity includes: a cell type component, a cell ID component and a cell geometry information component; The load data entry entity, interaction data entry entity, boundary condition data entity, constraint data entry entity and predefined field data entry entity all include: a regional geometry information component, an amplitude characteristic component and a physical quantity type component; The analysis step data entry entity includes: a calculation interval component, an iteration number constraint component and an analysis type component; The operation data entry entity includes: an assembly information component, a meshing information component, an analysis step information component, an input information component, and an output information component; The data entity at each node in the solver input and output process includes: temperature components, stress components and other target physical field components.

5. The method according to claim 3, characterized in that: The behavior of the data contained in the components of each module is constructed into a system, including: For the file import submodule, the object of the system is FileSystem, which is used to process the file entity. The responsibility of FileSystem is to perform business logic on the file entity, process the data attached to the components in the file entity, and update the processed data to the components. When the file type attached to the file type component attached to the file entity can be supported by FileSystem, FileSystem parses the supported file type and updates the parsing result to the data of the parsing component attached to the file entity; when it is necessary to support a new file format, create a new file type component and provide support in FileSystem; For the model submodule, the object of the system is ModelSystem, which handles the data process of model import and new creation; For the material submodule, the object of the system is MaterialSystem, which processes the data behaviors of various material entities; For the assembly submodule, the object of the system is AssemblySystem, which processes the association logic between models and materials; For the mesh unit submodule, the object of the system is MeshSystem, and the MeshSystem implements the update of the component data after the mesh unit entity is divided; For the analysis step submodule, the system object is StepSystem, which manages the update of the analysis step data entry entity and its component data; For the load submodule, the system object is LoadSystem, which manages the update of the load data entry entity and its component data; For the boundary condition submodule, the system object is BoundaryConditionSystem, which manages the update of boundary condition data entry entities and their component data; For the predefined field submodule, the system object is PredefinedFielSystem, and the PredefinedFielSystem manages the update of the predefined field data entry entity and its component data; For the interaction submodule, the system object is InteractionSystem, which manages the interaction data entry entity and the update of component data; For the constraint submodule, the system object is ConstraintsSystem, and the ConstraintsSystem manages the update of constraint data entry entities and their component data; For the analysis output submodule, the object of the system is AnalysisSystem, which manages the update of the analysis output data entry entity and its component data; For the job submodule, the object of the system is JobSystem, and the JobSystem manages the update of the job data entry entity and its component data.

6. The method according to any one of claims 1 to 5, characterized in that: When using data-oriented software architecture to build material submodules, including: Determine a model to be constructed; the model includes at least one component, each component includes at least one region; each region has a preset shape and material type; Each material type is regarded as an entity, and each feature of any material type is regarded as a component; the component is used to carry data corresponding to the feature; the feature includes at least one of the following: plasticity, linear elasticity, density component and temperature; According to the model, the corresponding components are loaded into containers in the entity, and the system is used to maintain the data in each component.

7. The method according to claim 3, characterized in that When a data-oriented development approach is used to build sub-functional modules, it also includes: The pre-processing module is used to process the system management entities and the data contained in the entities of each sub-functional module it contains, and output the processed data in the format required by the solver module; The solver module is used to create entities of each sub-function module in the solution process according to the data output by the pre-processing module, and mount the data type required by the solver for the entity, and then the system of each sub-function module processes the created entities and the data contained in their components, obtains the solution result based on the finite element analysis algorithm, and outputs the solution result in the format required by the post-processing module; The post-processing module is used to read the solution results, create actual post-processing entities and related component data of each sub-functional module, then render the results on the post-processing view, and respond to the user's viewing operation.

8. A CAE software construction system, characterized in that: include: The simulation scenario determination module is used to determine the simulation scenarios that the current version of CAE software needs to support, so as to determine the functions that it needs to support; A CAE software construction module, used to design the interaction and interface of the CAE software according to the functions to be supported, and determine a plurality of sub-function modules to be added to the CAE software based on the interaction and interface; At least one of the plurality of sub-function modules is constructed by using a data-oriented software design architecture; wherein, the following includes: taking the file record to be constructed by the file import sub-module as an entity; taking the model to be imported by the file import sub-module and the model to be created by the model sub-module as an entity; taking the material type created by the material sub-module for the simulation scene, the material type contained in the model imported by the file import sub-module, and the material type contained in the model created by the model sub-module as an entity; taking the assembly in the assembly sub-module as an entity; taking the cell divided by the grid division sub-module as an entity; taking the predefined field data entry managed by the predefined field sub-module as an entity; taking the load data entry managed by the load sub-module as an entity; taking the boundary condition data entry managed by the boundary condition sub-module as an entity; taking the interaction data entry managed by the interaction sub-module as an entity; taking the constraint sub-module as an entity. The constraint data entry created by the block is taken as an entity; the analysis step data entry created by the analysis step submodule is taken as an entity; the analysis output data entry created by the analysis output submodule is taken as an entity; the job data entry created by the job submodule is taken as an entity; the node data parsed in the solution input submodule is taken as an entity; the node data in the structured input data passed to the solver by the solver call submodule is taken as an entity; the calculation result of the node obtained from the solver output by the solution result processing submodule is taken as an entity; the solution result parsing submodule, the solution result rendering submodule and the solution result operation submodule use the data on the node obtained after the solver output data is parsed as an entity; when multiple sub-functional modules are constructed, the iteration of the current version of CAE software is completed to obtain an updated version of CAE software; the updated version of CAE software supports the simulation scenario.

9. An electronic device, characterized in that: include: at least one memory for storing a computer program; At least one processor is used to execute the program stored in the memory. When the program stored in the memory is executed, the processor is used to execute the method according to any one of claims 1 to 7.

Images