CAE (Computer Aided Engineering) software construction method, system and equipment

Abstract

The invention belongs to the field of software simulation, and particularly discloses a CAE software construction method, system and equipment, and the method comprises the steps: determining a simulation scene which needs to be supported by the current version of CAE software, so as to determine a function which needs to be supported by the current version of CAE software; determining a plurality of sub-function modules needing to be added in the CAE software according to the functions needing to be supported; constructing at least one sub-function module in the plurality of sub-function modules by adopting a data-oriented software design architecture; after the plurality of sub-function modules are constructed, completing iteration of the CAE software of the current version to obtain CAE software of an updated version; the CAE software of the updated version supports the simulation scene. Through the method and the device, the problems of software complexity and performance caused by coupling of a plurality of functional modules in a CAE software architecture are solved, so that the development efficiency of CAE software is improved, the software quality and the execution performance are improved, and the simulation experience of a user is improved.

Description

Technical Field

[0001] The present application belongs to the field of software simulation, and more specifically, to a CAE software construction method, system and device. Background Art

[0002] Computer Aided Engineering (CAE) software plays a key role in modern engineering design and analysis. CAE software uses finite element analysis (FEA) technology to help engineers simulate complex structures and materials and predict their behavior under different loads and boundary conditions. This method can effectively reduce experimental costs, speed up product development cycles, and improve design accuracy and reliability.

[0003] CAE software is widely used in a variety of industries such as aerospace, automotive, civil engineering, and electronics, and each industry has its own specific needs and standards. These needs and standards often cover multiple types of analysis, including structural analysis, thermal analysis, fluid mechanics analysis, electromagnetic field analysis, etc., and the needs and constraints of 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), requiring the software to be able to efficiently process and store this data, while being able to support a variety of standardized input and output file formats and maintain good compatibility. CAE software users are also diverse, including engineers, designers, researchers, etc., and different roles have different requirements for functions and interfaces. They need to customize models, boundary conditions, and analysis settings according to specific project requirements, which increases the complexity of requirements.

[0004] The architectural design of CAE software is a complex process that requires comprehensive consideration of multi-level architecture, modular design, performance optimization, user needs, technology selection and other factors. The design team needs to find a balance among these complexities to ensure the functionality, scalability and maintainability of the final product. Through reasonable architectural design, a solid foundation can be laid for the successful development of CAE software and the quality and ease of use of CAE software.

[0005] Traditional software design ideas usually design the overall architecture of the software based on the idea of ​​object-oriented design (OOD) or object-oriented programming (OOP). This is because it conforms to people's cognitive habits: everything has its own attributes (including commonalities and characteristics) and behaviors, and their respective behaviors affect each other and change their respective attributes. When dealing with complex problems, it is natural to abstract the various factors of the actual problem into models of categories, encapsulate their commonalities and characteristics, define their behaviors, and then subdivide the details of the entire requirement by levels and modules. In the design of CAE software, it is natural to abstract models, materials, assemblies, loads, boundary conditions, mesh units, etc. into classes, such as model classes, material classes, load classes, mesh unit classes, etc., and then their instances will be associated, combined or aggregated with each other, such as assemblies contain model objects, as well as material properties, etc., and load instances will hold references to the assemblies they act on. The pre-processing stage creates and manages these instances and the associations between them, then packages them into structured data files for the solver to process, outputs them to the solver for solving, and sends the solved result files to the post-processing module. The post-processing module processes the result files and presents them to the view for users to view and operate the results.

[0006] This traditional CAE software architecture design is characterized by: the models, solvers, and post-processing modules in traditional finite element software are often highly coupled, resulting in poor system flexibility and scalability. The use of class inheritance to implement different types of element and material models increases the complexity of the code, leading to difficulties in maintenance and expansion. Due to the close integration of data and logic and the side effects of OOD / OOP, traditional architectures may experience performance bottlenecks when processing 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] In view of the defects of the prior art, the purpose of this application is to provide a CAE software construction method, system and equipment, aiming to solve the problem that the models, solvers and post-processing modules in traditional CAE software are often highly coupled, resulting in poor flexibility and scalability of the system.

[0008] To achieve the above objectives, in a first aspect, the present application provides a CAE software construction method, comprising: Determine the simulation scenarios that the current version of CAE software needs to support in order to determine the functions it needs to support; Determine the number of sub-function modules that need to be added to the CAE software based on the functions that need to be supported; Adopting a data-oriented design (DOD) software design architecture to construct at least one of the plurality of sub-function modules; When the multiple sub-function 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.

[0009] This application develops CAE software through a data-oriented software design architecture. In this architecture, entities generally have no inheritance or sibling relationships. The difference between entities in different submodules is only the unique identification id and the data components in the container. This difference avoids the complex inheritance reference relationship in OOD / OOP, simplifies the data structure, and facilitates the subsequent iteration and expansion of new business entities.

[0010] In a possible implementation, 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.

[0011] In one possible implementation, the data-oriented software design architecture includes: entities, components and systems; specifically including: 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 components corresponding to the characteristics of each unit into the container of the corresponding entity; the components are used to carry the data corresponding to the characteristics, and the system is a pure function, and the objects of the system are the components in the entity, which are used to perform logical processing on the data carried by the components to update the data.

[0012] In a possible implementation, when a data-oriented software design architecture is used to construct a sub-functional module, it includes: Treat each file record to be constructed by the file import module as an entity; The model to be imported by the file import module and the model to be created by the model submodule are taken as entities; Take as entities the material types created by the material submodule for the simulation scene, the material types contained in the model imported by the file import submodule, and the material types contained in the model created by the model submodule; Treat each assembly in the assembly submodule as an entity; Treat each cell divided by the grid division submodule as an entity; Treat each predefined field data entry managed by the predefined field submodule as an entity; Treat each load data entry managed by the load submodule as an entity; Treat each boundary condition data entry managed by the boundary condition submodule as an entity; Treat each interaction data entry managed by the interaction submodule as an entity; Create each constraint data entry in the constraint submodule as an entity; Create each analysis step data entry in the analysis step submodule as an entity; The analysis output submodule creates each analysis output data entry as an entity; Create each job data entry in the job submodule as an entity; Treat each node data parsed in the solution input submodule as an entity; Treat each node data in the structured input data passed to the solver by the solver calling submodule as an entity; The calculation result of each node obtained by the solution processing submodule from the solver output is regarded as an entity; The solution result parsing submodule, solution result rendering submodule and solution result operation submodule take the data on each node obtained after the solver output data is parsed as an entity.

[0013] In a possible implementation, each characteristic corresponding to each entity is constructed into a component; The entity corresponding to the file may include: a file type component and a file parsing result component; The model corresponds to an entity, which may include: 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, which may include: an elastic component, a plastic component, a thermal conductivity component, an electrical conductivity component, and a density component; The assembly corresponding entity may include: 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 may include: 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 may include: a region geometry information component, an amplitude characteristic component, and a physical quantity type component; The analysis step data entry entity may include: a calculation interval component, an iteration number constraint component, and an analysis type component; The operation data entry entity may include: 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 may include: temperature components, stress components, and other target physical field components.

[0014] In one possible implementation, 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.

[0015] In a possible implementation, when a data-oriented software architecture is used to construct a material submodule, it includes: 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 of the object, the corresponding components are loaded into the container in the entity, and the system is used to maintain the data in each component.

[0016] In a possible implementation, when a data-oriented development method is used to construct a sub-functional module, the following is also included: 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.

[0017] In a second aspect, the present application provides a CAE software construction system, including: 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 is used to determine multiple sub-function modules that need to be added to the CAE software according to the functions that need to be supported; and to use a data-oriented software design architecture to construct at least one of the multiple sub-function modules; when the multiple sub-function modules are constructed, the current version of the CAE software is iterated to obtain an updated version of the CAE software; the updated version of the CAE software supports the simulation scenario.

[0018] In a third aspect, the present application provides an electronic device comprising: at least one memory for storing programs; and at least one processor for executing the programs stored in the memory. When the program stored in the memory is executed, the processor is used to execute the method described in the first aspect or any possible implementation of the first aspect.

[0019] In a fourth aspect, the present application provides a computer-readable storage medium, which stores a computer program. When the computer program runs on a processor, the processor executes the method described in the first aspect or any possible implementation of the first aspect.

[0020] In a fifth aspect, the present application provides a computer program product. When the computer program product runs on a processor, the processor executes the method described in the first aspect or any possible implementation of the first aspect.

[0021] It can be understood that the beneficial effects of the second to fifth aspects mentioned above can be found in the relevant description of the first aspect mentioned above, and will not be repeated here.

[0022] In general, the above technical solutions conceived by this application have the following beneficial effects compared with the prior art: The present application provides a CAE software construction method, system and equipment, and develops CAE software through a data-oriented DOD software design architecture such as entity-component-system. Since the entities in this architecture have different unique identification IDs and containers with different components, there is no other data; the file entity, material entity, etc. in this application are only because they are 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 components in the container, the entity has no other information, and there is no concept of category. This is the most essential difference from OOD / OOP, that is, entities generally have no inheritance or sibling relationships, and the difference between entities in different sub-modules is only the different unique identification IDs and different data components in the container. This difference avoids the complex inheritance reference relationship in OOD / OOP, simplifies the data structure, facilitates subsequent iterations to expand new business entities, and is more friendly to memory and CPU cache. At the same time, it 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

[0023] Figure 1 It is a flowchart of a CAE software construction method provided in an embodiment of the present application; Figure 2 It is an architecture diagram of a CAE software construction system provided in an embodiment of the present application; Figure 3 It is a schematic diagram of the structure of an electronic device provided in an embodiment of the present application. DETAILED DESCRIPTION

[0024] In order to make the purpose, technical solution and advantages of the present application more clearly understood, the present application is further described in detail below in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present application and are not used to limit the present application.

[0025] The term "and / or" in this article is a description of the association relationship of associated objects, indicating that there can be three relationships. For example, A and / or B can represent: A exists alone, A and B exist at the same time, and B exists alone. The symbol " / " in this article indicates that the associated objects are in an or relationship, for example, A / B means A or B.

[0026] In the embodiments of the present application, words such as "exemplary" or "for example" are used to indicate examples, illustrations or descriptions. Any embodiment or design described as "exemplary" or "for example" in the embodiments of the present application should not be interpreted as being more preferred or more advantageous than other embodiments or designs. Specifically, the use of words such as "exemplary" or "for example" is intended to present related concepts in a specific way.

[0027] The embodiments of the present application are described below in conjunction with the drawings in the embodiments of the present application.

[0028] It should be noted that, because CAE software has a wide range of applications, solves complex and professional problems, and has diverse users and compatibility requirements for industry ecosystems, these factors inevitably lead to complexity in the design and implementation of CAE software, which is mainly reflected in: 1. The hierarchical architecture should consider the user interface layer, application logic layer, data access layer, and computing layer to ensure that these layers can meet the functional needs of their respective fields, be efficient, easy to use, and scalable, and at the same time ensure that the layers can communicate and collaborate effectively.

[0029] 2. Based on the general process of simulation analysis, it is usually necessary to divide the software into various functional modules, such as pre-processing module, solver, post-processing, etc. Each module can be divided into smaller sub-modules. For example, the pre-processing module can be divided into model creation and import support sub-modules, material property stator module, assembly sub-module, boundary conditions and loads and interaction application sub-modules, meshing sub-modules, analysis type step modules, etc. according to the function. The solver has explicit and implicit analysis solutions, static, dynamic, fluid solutions and other sub-modules. The design of these modules must ensure loose coupling between modules to facilitate independent development and maintenance and combined use of them to solve specific analysis problems. If there is high coupling between modules, the flexibility of the system will be reduced and the maintenance cost will increase. For example, modifying a module will affect the functions of other modules, resulting in unreliable development, testing and maintenance costs and the final functions.

[0030] 3. In addition to the problems caused by the coupling between software modules, analysis problems often involve the coupling of 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 deal with these coupling relationships. At the same time, the solution methods and algorithms for 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.

[0031] Thus, as an example, Figure 1 A flow chart of a CAE software construction method provided in an embodiment of the present application is as follows: Figure 1As shown, the following steps are included: Step S101, determining the simulation scenarios that the current version of CAE software needs to support, so as to determine the functions that it needs to support; Step S102, determining a plurality of sub-function modules that need to be added to the CAE software according to the functions that need to be supported; Step S103, constructing at least one sub-function module among the plurality of sub-function modules by adopting a data-oriented software design architecture; Step S104, when the construction of the plurality of sub-function modules is completed, 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.

[0032] In a possible implementation, 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.

[0033] In one possible implementation, the data-oriented software design architecture includes: entities, components and systems; specifically including: 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 components corresponding to the characteristics of each unit into the container of the corresponding entity; the components are used to carry the data corresponding to the characteristics, and the system is a pure function, and the objects of the system are the components in the entity, which are used to perform logical processing on the data carried by the components to update the data.

[0034] It can be understood that data-oriented software architecture design is entity-component-system architecture, which can be referred to as (Entity-Component-System, ECS) architecture.

[0035] In a possible implementation, when a data-oriented software design architecture is used to construct a sub-functional module, it includes: Treat each file record to be constructed by the file import module as an entity; The model to be imported by the file import module and the model to be created by the model submodule are taken as entities; Take as entities the material types created by the material submodule for the simulation scene, the material types contained in the model imported by the file import submodule, and the material types contained in the model created by the model submodule; Treat each assembly in the assembly submodule as an entity; Treat each cell divided by the grid division submodule as an entity; Treat each predefined field data entry managed by the predefined field submodule as an entity; Treat each load data entry managed by the load submodule as an entity; Treat each boundary condition data entry managed by the boundary condition submodule as an entity; Treat each interaction data entry managed by the interaction submodule as an entity; Create each constraint data entry in the constraint submodule as an entity; Create each analysis step data entry in the analysis step submodule as an entity; The analysis output submodule creates each analysis output data entry as an entity; Create each job data entry in the job submodule as an entity; Treat each node data parsed in the solution input submodule as an entity; Treat each node data in the structured input data passed to the solver by the solver calling submodule as an entity; The calculation result of each node obtained by the solution processing submodule from the solver output is regarded as an entity; The solution result parsing submodule, solution result rendering submodule and solution result operation submodule take the data on each node obtained after the solver output data is parsed as an entity.

[0036] It should be noted that the CAE software will divide the model to be studied into many grid units in the pre-processing stage. Each grid unit is a tetrahedron (four vertices, four faces, each face is a triangle, similar to a triangular pyramid) or a hexahedron (similar to a cube) and other geometric bodies, and the input material properties and loads, predefined fields, and boundary condition data are dispersed into these grid units. The vertices, face centers, or body centers of these grid units are nodes, and the data of these nodes can be used to obtain the quantity at each position on the entire grid unit based on the distribution characteristics of the quantity. Pre-processing, solving, and post-processing are done in this way to disperse the physical quantities on the entire model into the values ​​on these nodes through a large number of nodes on the grid units, and then process or calculate the data on these nodes.

[0037] In a possible implementation, each characteristic corresponding to each entity is constructed into a component; The entity corresponding to the file may include: a file type component and a file parsing result component; The model corresponds to an entity, which may include: 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, which may include: an elastic component, a plastic component, a thermal conductivity component, an electrical conductivity component, and a density component; The assembly corresponding entity may include: 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 may include: 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 may include: a region geometry information component, an amplitude characteristic component, and a physical quantity type component; The analysis step data entry entity may include: a calculation interval component, an iteration number constraint component, and an analysis type component; The operation data entry entity may include: 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 may include: temperature components, stress components, and other target physical field components.

[0038] In one possible implementation, 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.

[0039] In a possible implementation, when a data-oriented software architecture is used to construct a material submodule, it includes: 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 of the object, the corresponding components are loaded into the container in the entity, and the system is used to maintain the data in each component.

[0040] In a possible implementation, when a data-oriented development method is used to construct a sub-functional module, the following is also included: 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.

[0041] In summary, the present application provides a method for constructing CAE software. Specific steps may include: conducting a demand analysis to determine simulation requirements based on the simulation scenarios that the CAE software is to support; determining the functional details that the current iteration of the CAE software is to support based on the simulation requirements; designing the interaction (User Experience, UE) and interface (UserInterface, UI) of the CAE software based on the functional details; based on the UE and UI design, conducting an outline design of the software functions and decomposing the functions into various sub-functional modules; applying the ECS architecture design based on the sub-functional module division to design the detailed design of each sub-functional module; based on the detailed design of each sub-functional module, using the ECS architecture coding to implement the function of each sub-module; based on the implementation of the sub-functional modules, using the ECS architecture combination to implement the overall functional flow; based on the implementation of the functional flow, releasing the test version and performing verification testing on the simulation scenario; based on the verification test process, adjusting and improving the release of the official version of the CAE software after this iteration.

[0042] Furthermore, the innovation of this application is that in view of the complexity of CAE software requirements and high performance requirements, the ECS architecture is adopted in the detailed design and coding implementation of the functional submodules of the software and the integration of the submodule functions of the entire new function. This architecture is described as follows: The ECS software architecture is 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 combination 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. 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 data mounted on an Entity, which carries the attributes of a certain part of the entity. It is a pure data structure that does not contain functions. That is, it only contains a specific data attribute but no behavior. System: A pure function does not contain data. It only cares about Entities with certain specific attributes (components), performs logical processing on the data in the component, and updates the processed data in the component. Scene, also called the world in some places, corresponds to the actual problems solved by this architecture, and is collectively referred to as Scene below. It is also a concept implicit in the ECS architecture.

[0043] In the ECS architecture, the relationship between the above four is: 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 this data. Different systems and entities organize interactions and logic in the scene to solve problems.

[0044] Through this application, we can efficiently design and develop CAE software based on the ECS architecture used in this construction method, greatly improve the code reusability and scalability of CAE software projects and the software performance improvement brought by this architecture, so as to efficiently and continuously expand the software functions and optimize the performance.

[0045] In a more specific embodiment, a CAE software construction method provided in this embodiment includes the following steps: Step 1.1, determine the simulation scenarios that the current version of CAE software should support: The CAE software version here can be the initial version starting from scratch, or a new version can be developed based on an existing version. They are collectively referred to as the current version, that is, the software version to be produced for the current iteration (whether it is the initial version iteration or the subsequent version iteration), which does not affect subsequent steps.

[0046] Based on the iteration rhythm, project cycle and project resources, the current version iteration will usually focus on supporting a type of simulation requirements. For example: assuming that the previous CAE software already supported static analysis (which can solve static analysis scenarios, such as structural strength analysis of bridges, load-bearing analysis of wall columns, fatigue analysis of screws, etc.), and the current version needs to support collision scenarios (such as chip equipment drop tests, car collision tests, etc.), then the current CAE software needs to support scenarios of dynamic analysis. The scenarios supported by the actual iteration include but are not limited to the example mentioned above. The actual scenarios are very broad, including a large number of scenarios classified as force, heat, electromagnetic, fluid and their coupling scenarios. The above example is only used to illustrate the relationship between the iterative version of the CAE software and the simulation scenario.

[0047] Step 1.2, based on the simulation scenario determined in step 1.1, determine which functions need to be implemented to support the analysis of the simulation scenario, and then clarify the main functions that the current iteration of the software version needs to support, so as to conduct a specific demand analysis.

[0048] Step 1.3: Based on the functional requirement analysis in step 1.2, perform UE and UI design to determine the interaction process details and interface details of the new function in the software version.

[0049] Step 1.4: Based on the UE / UI design of step 1.3, determine the functional details to be supported by each functional module and sub-functional module. Usually, the functional modules of CAE are divided as follows: Pre-processing can be divided into the following functions: file import sub-module, model sub-module, material sub-module, assembly sub-module, meshing 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.

[0050] The solver module can be divided into the following functions: solution input processing submodule, solver call submodule, and solution result processing submodule.

[0051] The post-processing module is divided into the following functions: solution result parsing submodule, solution result rendering submodule, and solution result operation submodule.

[0052] According to the requirements details in step 1.2 and the UE / UI details in step 1.3, the newly added functions will generally involve the three modules of pre-processing, solver, and post-processing, and the functions of one or more modules under each. We will make an outline design for each sub-functional module involved and determine the functional details (new or changed functions) that each sub-module needs to support. This outline design is equivalent to the refinement of the functions and requirements of each sub-module.

[0053] Taking the material module as an example, the common scenario is that the user imports or creates a model of the object to be analyzed in the simulation software. The model has one or more parts, and each part has one or more sections. Each section contains specific geometric shapes and material types. For example, to study car collision tests, the user imports a car model Model-Car. The wheel of the car is one of the parts, which we call part-wheel-A (assuming A corresponds to the left front wheel), and the wheel part can be divided into two sections, the tire and the wheel hub, named section-A and section-B respectively. For tire section-A, a 3D geometric model in the shape of a tire must be drawn in the simulation software first, and then its material must be specified as a certain rubber material, while section-B must also be assembled from a wheel hub-shaped geometric model and a certain metal material. The other parts of the car are processed in this way, and finally we get a car model in the simulation CAE software, including the geometric shapes and material types of each part of the car.

[0054] Therefore, in this simulation analysis scenario, building a car model requires creating or importing the material properties of each part of the car, that is, managing the dozens (possibly more) materials that make up the car. This is the function that the CAE software material sub-module needs to support; other simulation analysis scenarios such as thermal effect analysis of chips, bridge load-bearing analysis, etc. all require building geometric models and assembling material properties. The functions of the material sub-module are to create, import, and manage the various materials that make up the analysis target.

[0055] The other sub-function modules are similar, and the functional requirements of each sub-module are refined based on simulation steps 1.1 to 1.3. This process is called outline design, which does not involve specific software design, but is a functional division and detailed design.

[0056] Step 1.5: Based on the outline design of step 1.4, refine the design of each submodule with functional changes. In this process, the ECS (Entity-Component-System) architecture can be used to design the function of each submodule. The specific steps are as follows: Step 1.5.1, identify and establish the entity of each submodule: In the file import submodule and the model submodule, each file record is an entity; the model imported from the file and the model created in each model submodule are also entities; each material created for the simulation scene in the material module or attached to the model imported from the model file is an entity (but the various parameter data of the material will be abstracted as a component in the next step); each assembly part in the assembly submodule is also an entity; each cell after meshing can be used as an entity; each data record generated by the predefined field submodule, load submodule, boundary condition submodule, constraint submodule, analysis step submodule, analysis output submodule, and job submodule is an entity. The data or file objects processed by the solver and post-processing modules can be identified as entities in this way, and will not be explained one by one here.

[0057] It can be seen that these entities in the ECS architecture have different unique identification ids and containers with different components. There is no other data. The file entities and material entities described here and below are only because they are 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 components in the container, the entities have no other information, and there is no concept of category. This is the most essential difference from OOD / OOP, that is, entities generally have no inheritance or sibling relationships, and the difference between entities in different sub-modules is only the different unique identification ids and different data components in the container. This difference avoids the complex inheritance reference relationship in OOD / OOP, simplifies the data structure, facilitates subsequent iterations to expand new business entities, is more friendly to memory and CPU cache, and avoids the problem of multi-threaded data synchronization caused by complex reference inheritance, and is friendly to multi-threaded parallel computing.

[0058] Step 1.5.2, identify all entity-related data in step 1.5.1 above, identify these data according to data type and create components, and then put the entity-related data into the entity container in the form of component objects. The components related to each submodule entity are described as follows: the components of the file entity include file type components (including file path and file suffix), file parsing result components, etc.; the model entity includes part collection components, section collection components, material collection components, assembly information collection components, etc.; the material entity contains various material property-related components, such as elastic components, plastic components, thermal conductivity components, electrical conductivity components, density components, etc. Different material entities contain one or several of these components and the components contain relevant parameters. For example, if a certain material contains a density component, its container has a density component, which will record the density of the research target; the assembly part entity can contain components such as part collection components, section collection components, geometric data components, material data components, assembly information components, etc.; the mesh unit entity can contain unit type components, unit id components, unit geometric information components, etc.

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

[0060] The predefined field sub-module, load sub-module, boundary condition sub-module, constraint sub-module, analysis step sub-module, analysis output module, job module, solver, and post-processing sub-modules can all create the data associated with or contained in their respective entities in the form of data components and then add them to the container of the corresponding entity.

[0061] Step 1.5.3, identify and create the System objects in each submodule. For example, the System object of the file import submodule can be called FileSystem, which is used to process the file entity. The responsibility of FileSystem is to perform business logic on the file entity. 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 attached to the file entity can be supported by FileSystem, FileSystem will parse the format and update the parsing result to the data of the parsing component attached to the 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 does not affect the previously supported types and processing logic at all. If it is in OOD / OOP, it may be necessary to modify the base class interface to use the polymorphic feature to achieve this effect, and the support logic for the existing base class and the already implemented file format will be affected to a certain extent. Therefore, this kind of System in the ECS architecture that purely processes data behavior without paying attention to the characteristics of the data itself is conducive to maintaining the stability and continuous expansion of functions.

[0062] In this way, we can design System objects of other sub-modules: the ModelSystem of the model sub-module handles the model import and new data process; the MaterialSystem of the material sub-module handles the data behavior of various material entities; the AssemblySystem of the assembly sub-module handles the association logic between the model and the material; the MeshSystem of the mesh unit sub-module implements the update of component data after the division of the mesh unit entity; the design of the System of other functional modules is similar, providing behavioral operations of the data in the component for the corresponding entity and updating the changed data to the component.

[0063] Some of these system behaviors are triggered by UE operations on the interface, and some are automatically triggered by analysis steps in the simulation analysis process. In essence, they all trigger the system to implement various functions to manage entities and the data in the components contained in the entities.

[0064] Step 1.5.4: After the submodules are designed in detail according to steps 1.5.1, 1.5.2, and 1.5.3, another step is needed, which is to process the entity and system data of each submodule in the scene, summarize their behaviors, and handle the communication logic between modules, and realize the logic of the final new function after exchanging data. Specifically, it is as follows: Step 1.5.4.1, in the pre-processing scenario, it is necessary to process the entities managed by the System of each pre-processing sub-module and the data contained in the entities, and organize them as input data of the solver in the format required by the solver.

[0065] Step 1.5.4.2, in the solution scenario, based on the input data given by the solution system before loading, create entities in the solution process, and mount the solver's core data types for the entities. Then the solution system processes the data contained in these entities and 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 post-processing requirements.

[0066] Step 1.5.4.3, after obtaining the result given by the solution module, the post-processing module enters the post-processing scene. The System of the post-processing module reads the result data, creates the actual post-processing entity and related component data, and then renders the result to the user on the post-processing view. Based on the user's operation, the user can view the spatial local result data or the result at a certain point in time, and can also view the dynamic process over a period of time.

[0067] 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 to create entities, various components, and system classes, 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 three modules of pre-processing, solver, and post-processing, and present the results to the UI based on UE operations. The specific coding implementation process depends on the design of the previous step and the actual development iteration. Those skilled in the art can refer to the above examples for further implementation, which will not be repeated here.

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

[0069] Figure 2 This is a CAE software construction system architecture diagram provided by the embodiment of the present application, such as Figure 2 As shown, including: The simulation scenario determination module 210 is used to determine the simulation scenarios that the current version of CAE software needs to support, so as to determine the functions that need to be supported; The CAE software construction module 220 is used to determine multiple sub-function modules that need to be added to the CAE software according to the functions that need to be supported; and to use a data-oriented software design architecture to construct at least one of the multiple sub-function modules; when the multiple sub-function modules are constructed, the current version of the CAE software is iterated to obtain an updated version of the CAE software; the updated version of the CAE software supports the simulation scenario.

[0070] It should be understood that the above-mentioned system is used to execute the methods in the above-mentioned embodiments. The implementation principles and technical effects of the corresponding program modules in the system are similar to those described in the above-mentioned methods. The working process of the system can refer to the corresponding process in the above-mentioned method and will not be repeated here.

[0071] Based on the method in the above embodiment, the embodiment of the present application provides an electronic device, such as Figure 3 As shown, the electronic device may include: a processor 310, a communication interface 320, a memory 330 and a communication bus 340, wherein the processor 310, the communication interface 320 and the memory 330 communicate with each other via the communication bus 340. The processor 310 may call the logic instructions in the memory 330 to execute the method in the above embodiment.

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

[0073] Based on the method in the above embodiment, an embodiment of the present application provides a computer-readable storage medium, which stores a computer program. When the computer program runs on a processor, the processor executes the method in the above embodiment.

[0074] Based on the method in the above embodiment, an embodiment of the present application provides a computer program product. When the computer program product runs on a processor, the processor executes the method in the above embodiment.

[0075] It is understandable that the processor in the embodiment of the present application may be a central processing unit (CPU), or other general-purpose processors, digital signal processors (DSP), application-specific integrated circuits (ASIC), field programmable gate arrays (FPGA) 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.

[0076] The method steps in the embodiments of the present application can be implemented by hardware or by a processor executing software instructions. The software instructions can be composed of corresponding software modules, and the software modules can be stored in random access memory (RAM), flash memory, read-only memory (ROM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), registers, hard disks, mobile hard disks, CD-ROMs, or any other form of storage medium 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 can also be a component of the processor. The processor and the storage medium can be located in an ASIC.

[0077] In the above embodiments, it can be implemented in whole or in part by software, hardware, firmware or any combination thereof. When implemented by 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 process or function described in the embodiment of the present application is generated in whole or in part. The computer may be a general-purpose computer, a special-purpose computer, a computer network, or other programmable device. The computer instructions may be stored in a computer-readable storage medium or transmitted through the computer-readable storage medium. The computer instructions may be transmitted from a website site, computer, server or data center to another website site, computer, server or data center by wired (e.g., coaxial cable, optical fiber, digital subscriber line (DSL)) or wireless (e.g., infrared, wireless, microwave, etc.) means. The computer-readable storage medium may be any available medium that a computer can access or a data storage device such as a server or data center that includes one or more available media integrated. The available medium may be a magnetic medium (e.g., a floppy disk, a hard disk, a tape), an optical medium (e.g., a DVD), or a semiconductor medium (e.g., a solid-state drive (SSD)), etc.

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

[0079] It will be easily understood by those skilled in the art that the above description is only a preferred embodiment of the present application and is not intended to limit the present application. Any modifications, equivalent substitutions and improvements made within the spirit and principles of the present application shall be included in the scope of protection 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; Determine the number of sub-function modules that need to be added to the CAE software based on the functions that need to be supported; Adopting a data-oriented software design architecture to construct at least one sub-function module among the plurality of sub-function modules; When the multiple sub-function 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.

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 components corresponding to the characteristics of each unit into the container of the corresponding entity; the components are used to carry the data corresponding to the characteristics, and the system is a pure function, and the objects of the system are the components in the entity, which are used to perform logical processing on the data carried by the components to update the data.

4. The method according to claim 3, characterized in that When using data-oriented software design architecture to build sub-functional modules, it includes: Treat each file record to be constructed by the file import module as an entity; The model to be imported by the file import module and the model to be created by the model submodule are taken as entities; Take as entities the material types created by the material submodule for the simulation scene, the material types contained in the model imported by the file import submodule, and the material types contained in the model created by the model submodule; Treat each assembly in the assembly submodule as an entity; Treat each cell divided by the grid division submodule as an entity; Treat each predefined field data entry managed by the predefined field submodule as an entity; Treat each load data entry managed by the load submodule as an entity; Treat each boundary condition data entry managed by the boundary condition submodule as an entity; Treat each interaction data entry managed by the interaction submodule as an entity; Create each constraint data entry in the constraint submodule as an entity; Create each analysis step data entry in the analysis step submodule as an entity; The analysis output submodule creates each analysis output data entry as an entity; Create each job data entry in the job submodule as an entity; Treat each node data parsed in the solution input submodule as an entity; Treat each node data in the structured input data passed to the solver by the solver calling submodule as an entity; The calculation result of each node obtained by the solution processing submodule from the solver output is regarded as an entity; The solution result parsing submodule, solution result rendering submodule and solution result operation submodule take the data on each node obtained after the solver output data is parsed as an entity.

5. The method according to claim 3, characterized in that: Build each characteristic corresponding to each entity into a component; The entity corresponding to the file may include: a file type component and a file parsing result component; The model corresponds to an entity, which may include: 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, which may include: an elastic component, a plastic component, a thermal conductivity component, an electrical conductivity component, and a density component; The assembly corresponding entity may include: 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 may include: 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 may include: a region geometry information component, an amplitude characteristic component, and a physical quantity type component; The analysis step data entry entity may include: a calculation interval component, an iteration number constraint component, and an analysis type component; The operation data entry entity may include: 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 may include: temperature components, stress components, and other target physical field components.

6. 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.

7. The method according to any one of claims 1 to 6, 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 of the object, the corresponding components are loaded into the container in the entity, and the system is used to maintain the data in each component.

8. 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.

9. 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 is used to determine multiple sub-function modules that need to be added to the CAE software according to the functions that need to be supported; and to use a data-oriented software design architecture to construct at least one of the multiple sub-function modules; when the multiple sub-function modules are constructed, the current version of the CAE software is iterated to obtain an updated version of the CAE software; the updated version of the CAE software supports the simulation scenario.

10. 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 8.

Images