Multi-process industrial design software simulation method and device based on instruction set architecture building

Abstract

Provided are a multi-process industrial design software simulation method and device based on instruction set architecture building, a computer-readable medium, and a computer program product. The method comprises: building an instruction set architecture (S101); decomposing a simulation procedure into functional units, and mapping instruction set function modules to the functional units (S102); encapsulating instructions in the instruction set function modules, and providing instruction interfaces for the instruction set function modules (S103); executing a pre-check function, an instruction parameter concatenation function, an instruction running function, and a post-check function for the instructions in the instruction set function modules by means of the instruction interfaces, and storing the instructions that have completed the pre-check function, the instruction parameter concatenation function, the instruction running function, and the post-check function in an execution list; and during the execution of the simulation procedure, cyclically executing multiple instructions in the execution list in a multi-process manner, and starting a process when each instruction is executed (S104).

Description

Multi-process industrial design software simulation method and device based on instruction set architecture

[0001] This application claims priority to the Chinese patent application filed with the China Patent Office on March 22, 2024, with application number 202410331585.9, the entire contents of which are incorporated by reference into this application. Technical Field

[0002] The present application relates to the field of industrial design simulation technology, for example, to a multi-process industrial design software simulation method and device based on an instruction set architecture. Background Art

[0003] Industrial design simulation technology is a computer simulation technology based on computer models. It predicts, analyzes and optimizes industrial production processes by simulating the operation process and behavior of actual industrial systems. With the development of computer technology and numerical calculation technology, the application scope of industrial design simulation technology continues to expand, and the application of simulation technology has become more extensive and important. Computer Aided Engineering (CAE) is mainly used for industrial design simulation. CAE software can analyze the performance, safety and reliability of projects and products, simulate their future working status and operation behavior, thereby optimizing the design and ensuring the availability and reliability of future project and product functions and performance. Industrial design simulation includes multiple functional modules, among which pre-processing, meshing, numerical solution and post-processing are key steps in the industrial design simulation process.

[0004] International application PCT / CN2023 / 139109 discloses a three-dimensional geometric model meshing method, system, device and computer-readable medium, which avoids the meshing of complex three-dimensional geometric models, but does not solve the task allocation between pre-processing, meshing and numerical solution.

[0005] One task allocation method used in related technologies is the single-process approach, which couples all code together and interconnects functional modules. While this approach may be more convenient for simple problems or small datasets, the pre-processing of a single process can be time-consuming when dealing with large-scale and complex problems. Furthermore, meshing and numerical solution are typically provided in the form of executable files (exe) within the entire software, with meshing and numerical solution implemented by different developers, offering the advantage of decoupling. Each exe file has input parameters and produces output after execution. For a single exe file, the input parameters must be verified before execution, the exe file must be executed, and finally the output parameters after the process execution must be verified. However, if the software uses multiple exe files for parallel computing, these files may need to communicate frequently to share data and synchronize computational progress. Furthermore, debugging parallel programs can be relatively complex, especially when multiple executable files are running simultaneously, making it even more difficult to locate and resolve problems.

[0006] Therefore, it is necessary to provide an industrial design simulation method that can simplify the operating process, make process management more flexible, and improve the degree of automation.

[0007] Summary of the Invention

[0008] This application provides a multi-process industrial design software simulation method built on an instruction set architecture, which can reduce the complexity of parallel program debugging during the simulation process, simplify the operation process, and improve the flexibility and automation of module management.

[0009] The present invention provides a multi-process industrial design software simulation method based on an instruction set architecture, including:

[0010] Build an instruction set architecture, which includes an instruction set base class and an instruction set functional module. The instruction set base class is configured to provide a basic interface for instructions, and the instruction set functional module is configured to implement specified functions.

[0011] Decompose the simulation process into functional units and map the instruction set functional modules to the functional units, wherein the functions performed by the functional units are performed by instructions;

[0012] Encapsulating instructions in an instruction set functional module and providing an instruction interface for the instruction set functional module, wherein the instructions correspond to the functions implemented by the instruction set functional module, and the instruction interface corresponds to a pre-verification function, an instruction parameter splicing function, an instruction execution function, and a post-verification function;

[0013] The pre-check function, instruction parameter splicing function, instruction running function, and post-check function are executed on the instructions encapsulated in the instruction set function module through the instruction interface, and the instructions after the pre-check function, instruction parameter splicing function, instruction running function and post-check function are stored in the execution list; during the execution simulation process, multiple instructions in the execution list are executed cyclically in a multi-process manner, and a process is started when each instruction is executed.

[0014] In one embodiment, each instruction, when executed, initiates a process including:

[0015] Checking whether the parameters input into each instruction are correct and whether the required file exists in the corresponding directory, and in response to determining that the required file does not exist in the corresponding directory, feeding back the checking result to the user;

[0016] In response to determining that the required files exist in the corresponding directory, combining the parameters required for each command in the form of command line parameters;

[0017] Provide a running function for each instruction to execute the instruction line;

[0018] Checking whether the output format of the output file after each instruction is executed is correct, and in response to determining that the output format of the output file is correct, outputting the output file, and terminating the execution of the process corresponding to each instruction;

[0019] Among them, multiple instructions in the execution list are executed in a loop, and the output file of the previous instruction is used as the input file required by the next instruction;

[0020] In response to determining that the process corresponding to any one of the instructions fails to execute, the simulation process ends.

[0021] In one embodiment, the instruction set functional module includes: a verification module, a preparation module, a mesh generation module, and a numerical solution module;

[0022] Functional units include: pre-processing unit, mesh generation unit and numerical solution unit;

[0023] The mapping of the instruction set function module to the function unit includes:

[0024] The pre-processing unit corresponds to the verification module and the preparation module, the meshing unit corresponds to the meshing module, and the numerical solution unit corresponds to the numerical solution module.

[0025] In one embodiment, the instructions encapsulated by the verification module include:

[0026] Verify that material property instructions are assigned to all models;

[0027] Check whether the priority instructions for using materials are set for the overlapping areas of the model;

[0028] Check whether the air box is set as the solution domain instruction;

[0029] Verify that the boundary conditions and excitations are set correctly;

[0030] Verify that the parameters for generating the mesh are set correctly; and

[0031] Check whether the step size and solution time of the numerical solution are set as instructed.

[0032] In one embodiment, the instructions for preparing the module package include: a write model instruction, a material file instruction, a boundary condition instruction, and an excitation instruction.

[0033] In one embodiment, the instructions encapsulated by the mesh generation module include slicing instructions, mesh generation instructions, and encryption optimization instructions.

[0034] In one embodiment, the instructions encapsulated by the numerical solution module include: thermodynamic solution instructions, electromagnetic solution instructions, stress solution instructions, and fluid solution instructions.

[0035] An embodiment of the present application provides a multi-process simulation device built based on an instruction set architecture, including a memory, a processor, and a computer program stored in the memory. When the processor executes the computer program, it implements a multi-process industrial design software simulation method built based on the instruction set architecture.

[0036] An embodiment of the present application provides a computer-readable medium having a computer program stored thereon. When the computer program is executed by a processor, a multi-process industrial design software simulation method based on an instruction set architecture is implemented.

[0037] An embodiment of the present application provides a computer program product, including a computer program. When the computer program is executed by a processor, it implements a multi-process industrial design software simulation method built based on an instruction set architecture. BRIEF DESCRIPTION OF THE DRAWINGS

[0038] FIG1 is a software architecture diagram of a multi-process industrial design software simulation method based on an instruction set architecture according to an embodiment of the present application;

[0039] FIG2 is a multi-process flow chart of a multi-process industrial design software simulation method based on an instruction set architecture according to an embodiment of the present application;

[0040] FIG3 is a software architecture diagram of TurboT-BCA, a thermal circuit extraction software for a multi-process industrial design software simulation method based on an instruction set architecture according to an embodiment of the present application;

[0041] FIG4 is a flowchart of a multi-process industrial design software simulation method based on an instruction set architecture according to an embodiment of the present application. DETAILED DESCRIPTION

[0042] FIG1 is a software architecture diagram of a multi-process industrial design software simulation method based on an instruction set architecture according to an embodiment of the present application. In this embodiment, the instruction set is implemented by the Command base class. As shown in FIG4 , the multi-process industrial design software simulation method based on the instruction set architecture includes:

[0043] Step S101: Building an instruction set architecture, wherein the instruction set architecture includes an instruction set base class 100 (Command base class) and an instruction set functional module (Command functional module) (the instruction set functional module includes a verification module 210, a preparation module 220, a mesh generation module 230, and a numerical solution module 240). The instruction set base class 100 is configured to provide a basic interface for instructions, and the instruction set functional module is configured to implement specified functions.

[0044] Step S102, mapping instruction set function modules, breaking down the simulation process into function units, and mapping the instruction set function modules with the function units, wherein the functions performed by the function units are executed through instructions;

[0045] Step S103: Encapsulate instructions in the instruction set function module and provide an instruction interface for the instruction set function module. The instructions correspond to the functions implemented by the instruction set function module. The instruction interface corresponds to a pre-check function, an instruction parameter splicing function, an instruction execution function, and a post-check function.

[0046] Step S104, execute the pre-check function, instruction parameter splicing function, instruction running function, and post-check function on the instructions in the instruction set functional module through the instruction interface, and the instructions after executing the pre-check function, instruction parameter splicing function, instruction running function, and post-check function are stored in the execution list. When executing the simulation process, multiple instructions in the execution list are executed cyclically in a multi-process manner, and each instruction starts a process.

[0047] The execution list can be stored in computer memory, local disk, database, network storage or cache system.

[0048] The construction of an instruction set architecture helps to divide the system into clear modules, thereby improving the maintainability of the system. In addition, dividing the system into independent modules makes it easier to modify, update, and maintain the system, which helps to improve code reusability and better optimize performance.

[0049] As shown in Figures 1 and 3 , a processing base class 110, a verification module 210, a preparation module 220, a meshing module 230, and a numerical solution module 240 can be provided. The processing base class 110 is a subclass of the instruction set base class 100. The submodules of the verification module 210, the preparation module 220, the meshing module 230, and the numerical solution module 240 are the verification submodule 211, the preparation submodule 221, the meshing submodule 231, and the numerical solution submodule 241, respectively. The meshing submodule 231 includes a slicing unit, a mesh generation unit, and an optimization and encryption unit. Each submodule and unit contains multiple instructions to achieve code reuse and modularization.

[0050] For one of the instructions, the instruction interfaces that need to be provided are: first, a pre-check is performed to check whether the input parameters of the instruction are correct and whether the required file exists in the corresponding directory; secondly, the parameters required by the instruction are combined with the parameters of the instruction line; then the instruction running function is provided; finally, a post-execution check is performed to check whether the output file is correct after the instruction is executed.

[0051] In one embodiment, the format of the command line instruction combined with the command line parameters is:

[0052] C: / Program Files / Float / slicer.exe"CT-2-2.sat CT-2-2.pgn hybrid-fast-plane xy-material material.xml. Among them, C: / Program Files / Float / slicer.exe: This part specifies the path to the executable program to be run. Among them, a program named "slicer.exe" is located in the "C: / Program Files / Float / " directory. "CT-2-2.sat" is an input parameter, which is the path to the input file required by the "slicer.exe" program, and the file name is "CT-2-2.sat". "CT-2-2.pgn" is another input parameter, which is also the name of the output file generated by the previous program. "hybrid" is a parameter that specifies the slicing method, and "hybrid" means that it uses a hybrid mode for slicing. "-fast" is a flag that instructs the program to run in fast mode. "-plane xy" is another option that instructs the program to perform slicing on the xy plane. "-material "material.xml" is a parameter that specifies material information, and the file name is "material.xml".

[0053] In one embodiment, in step S104, each instruction starts a process, including:

[0054] Step S1041, pre-check: Check whether the parameters input for the command to be executed are correct and whether the required file exists in the corresponding directory. In response to determining that the required file does not exist in the corresponding directory, the check result is fed back to the user. In response to determining that the required file exists in the corresponding directory, the process proceeds to step S1042.

[0055] Step S1042, command parameter splicing: combining the parameters required by the command to be executed in the form of command line parameters;

[0056] Step S1043, instruction execution: providing an execution function of the instruction to be executed to execute the instruction line;

[0057] Step S1044, post-verification: checking the output file after the instruction is executed to check whether the output format of the output file is correct. In response to determining that the output format of the output file is correct, outputting the output file, and providing the output file to the next process;

[0058] Among them, multiple instructions in the list are executed cyclically, and the output file of the previous instruction is used as the input file required by the next instruction;

[0059] In response to determining that the process corresponding to any one of the instructions fails to execute, the simulation process ends.

[0060] In one embodiment, a simulation process includes three processes. The first process requires the simulation file 1.pgn and outputs 1.g3d. Then, the process first checks whether the 1.pgn file exists in the simulation folder in step S1041. In response to determining that the 1.pgn file exists in the simulation folder, the instruction parameter splicing and function execution are performed. Then, step S1044 is performed on the output file after the operation to check whether the 1.g3d file is generated correctly (that is, to check whether the output format of the 1.g3d file is correct). In response to determining that the 1.g3d file is generated correctly, the first process is executed.

[0061] After the first process is completed, the second process is started. The required input file is 1.g3d. In step S1041, the second process verifies whether the 1.g3d file exists. If the 1.g3d file exists in the simulation folder, the second process performs instruction parameter splicing and function execution. Then, the second process performs step S1044 on the output file. If the output file is 2.mesh, the second process verifies whether the output file 2.mesh exists and whether the output format of the 2.mesh file is correct. If the output format of the 2.mesh file is correct, the second process is completed.

[0062] The third process is executed in the same way, and the cycle continues until the last process is completed, at which point the entire simulation process ends.

[0063] If, in step S1041 or step S1044, no file requiring pre-verification or post-verification is found in a certain process, the system will feedback the information to the user, and the simulation process ends. The user can modify the data of a certain process based on the information fed back by the system.

[0064] The following is the instruction execution logic code of one of the processes in one embodiment:

[0065] The execution logic of other instructions is similar: "onPreCheck": performs pre-processing checks, "onInit": executes instruction parameter concatenation, "onRun": represents instruction execution, and "onPostCheck": performs post-processing checks. "onRun" calls an executable file to execute specific logic.

[0066] In one embodiment, the instruction set functional module includes: a verification module 210, a preparation module 220, a mesh generation module 230, and a numerical solution module 240;

[0067] The verification module 210 is configured to perform parameter verification before executing the simulation process; the preparation module 220 is configured to prepare the files required to execute each instruction before executing the simulation process; the grid generation module 230 is configured to divide the 3D or 2.5D grid, generate the grid, and perform encryption and optimization processing; the numerical solution module 240 is configured to solve physical problems based on the encrypted and optimized grid, such as solving thermodynamic problems, electromagnetic problems, stress problems or fluid problems.

[0068] The functional units after the simulation process is disassembled include: pre-processing unit, mesh generation unit and numerical solution unit;

[0069] The pre-processing unit is set to perform parameter verification and prepare files required to execute instructions before executing the simulation process; the mesh generation unit is set to divide the 3D or 2.5D mesh, generate the mesh, and perform encryption and optimization processing; the numerical solution unit is set to solve physical problems based on the encrypted and optimized mesh, such as solving thermodynamic problems, electromagnetic problems, stress problems or fluid problems.

[0070] The pre-processing unit corresponds to the verification module 210 and the preparation module 220 , the mesh generation unit corresponds to the mesh generation module 230 , and the numerical solution unit corresponds to the numerical solution module 240 .

[0071] As shown in Figure 1, the instruction set base class 100 implements some basic interfaces for instructions, such as instruction status and whether the instruction is executed. The verification module 210 and the preparation module 220 perform some pre-simulation parameter verification and file preparation. The processing base class 110 is the base class for process instructions. It encapsulates all modules into instructions and runs these instructions in a multi-process manner.

[0072] When the process is running, each instruction has pre-processing and post-processing. Pre-processing corresponds to step S1041. Pre-processing is used to verify whether the execution conditions of the instruction are met before the instruction is executed. If the instruction execution conditions are not met, the user is prompted to which link has a problem. If the instruction execution conditions are met, the instruction parameter splicing process corresponding to step S1403 and the instruction running process corresponding to step S1404 are performed. After the instruction is run, post-processing is required. Post-processing corresponds to step S1404 and is used to verify whether the output data is correct after the instruction is executed. If the output data is incorrect, the user will be prompted to where the problem occurred so that the user can make corrections according to the prompt information. If the output data is correct, the process ends.

[0073] In one embodiment, the instructions encapsulated by the verification module 210 include:

[0074] Verify that material property instructions are assigned to all models;

[0075] Check whether the priority instructions for using materials are set for the overlapping areas of the model;

[0076] Check whether the air box is set as the solution domain instruction;

[0077] Verify that the boundary conditions and excitations are set correctly;

[0078] Verify that the parameters for generating the grid are set correctly;

[0079] Check whether the step size and solution time of the numerical solution are set as instructed.

[0080] In one embodiment, the instructions packaged by the preparation module 220 include: write model instructions, material file instructions, boundary condition instructions, and excitation instructions.

[0081] The write model instruction includes 3D modeling geometry parameters, the material file instruction includes material property parameters, the boundary condition instruction includes boundary condition parameters, and the excitation instruction includes excitation parameters.

[0082] During the implementation process, the instructions encapsulated by the preparation module 220 also include other auxiliary conditional instructions, such as initial condition instructions, output setting instructions, etc., and the required instructions can be called according to the requirements of the simulation process.

[0083] In one embodiment, the instructions encapsulated by the mesh generation module 230 include slice instructions, mesh generation instructions, and encryption optimization instructions.

[0084] Slice commands can be used to slice the model uniformly, adaptively, layered, normal, or in a specific direction, or even unstructured. The choice of slice depends on the nature of the simulation, the geometry of the model, and the accuracy requirements for the simulation results. Multiple slice commands can be configured for easy access.

[0085] When the slicing process is completed, the mesh generation process begins. The mesh generation instruction can generate structured meshes or unstructured meshes for the sliced ​​model, or it can generate adaptive meshes.

[0086] After the initial mesh is generated, encryption or optimization algorithms are needed to adjust the mesh to improve the quality of the mesh, reduce mesh distortion, and improve the accuracy and stability of the simulation.

[0087] In one embodiment, the instructions encapsulated by the numerical solution module 240 include: thermodynamic solution instructions, electromagnetic solution instructions, stress solution instructions, and fluid solution instructions.

[0088] Thermodynamics solvers: These involve the transfer of heat and energy, as well as the behavior of matter at varying temperatures and pressures. Simulation areas related to thermodynamics include heat conduction, heat transfer, convection, and phase change, and are used in heat exchanger and thermal management system design.

[0089] Electromagnetic solving instructions: involve modeling and solving electric and magnetic fields, which can be applied to electromagnetic field analysis, electromagnetic wave propagation, electromagnetic induction and other fields, and used to design electromagnetic equipment, radio frequency devices, antennas, etc.

[0090] Stress solving commands: These involve the forces and deformations of materials. This includes structural analysis, elasticity, plasticity, etc., to evaluate the strength, durability, and safety of structural components.

[0091] Fluid solving instructions: These involve aspects such as fluid motion and pressure distribution. These include aerodynamics, hydrodynamics, and combustion fluid mechanics, and are used to design aircraft airfoils, automobile exteriors, and piping systems.

[0092] In practical applications, different instructions of the numerical solution module 240 may be selected according to different simulation requirements.

[0093] In the aforementioned embodiment, the instruction set is implemented using the Command class. Those skilled in the art will appreciate that, depending on different requirements, other classes may be used to implement the instruction set, and the execution process and architecture of this application may also be used.

[0094] A multi-process simulation device built based on an instruction set architecture includes a memory, a processor, and a computer program stored in the memory. The processor is used to implement a multi-process industrial design software simulation method built based on the instruction set architecture when executing the computer program.

[0095] A computer-readable medium having a computer program stored thereon, wherein when the computer program is executed by a processor, the computer program implements a multi-process industrial design software simulation method based on an instruction set architecture. The computer-readable storage medium may be a non-transitory computer-readable storage medium.

[0096] A computer program product includes a computer program. When the computer program is executed by a processor, it implements a multi-process industrial design software simulation method based on an instruction set architecture.

[0097] Excluding post-processing during the simulation process, this application divides the entire simulation process into multiple modules, including a verification module, a preparation module, a meshing module, and a numerical solution module. At the same time, the entire simulation process is broken down into multiple corresponding functions, including pre-processing, meshing, and numerical solution, each of which is further divided into several sub-modules. To meet this demand, this application provides an instruction set architecture model that is implemented in a multi-process manner.

[0098] Each module encapsulates multiple instructions, including verification instructions, file writing instructions, mesh slicing instructions, 2.5D mesh generation instructions and mesh optimization instructions, and solution algorithm instructions for numerical solutions. In actual applications, there may be some other instructions, but the number of instructions does not affect the architecture.

[0099] As shown in FIG3 , in one embodiment:

[0100] In CAE software, taking the thermal circuit extraction software TurboT-BCA as an example, the pre-processing function of the simulation process, including verification module 210, encapsulates commands such as verifying whether the 3D model material is set correctly, verifying whether the air domain is set, verifying whether the thermal conductivity coefficient and heat source are set, and verifying whether the observation point of the heat source is set. The preparation module 220 encapsulates commands such as writing the model material priority set by the user in the graphical user interface (GUI) to a file, writing the 3D model to a file, and writing data such as the heat transfer coefficient (HTC) and heat source (Powermap) to a file.

[0101] The instructions encapsulated by the mesh partitioning module 230 include: instructions for loading a printed circuit board layout (PCB Layout) file, instructions for using the data in the layout, instructions for modeling the pins (PINs) under the packaging (PKG) model, and instructions for cutting the PKG; instructions for slicing the entire model according to key points; instructions for conformal processing of the model; instructions for partitioning the mesh after slicing; instructions for density processing of the mesh after partitioning, etc.

[0102] The instructions encapsulated by the numerical solution module 240 include: instructions for performing numerical solution on the thermal circuit, and then performing thermal circuit extraction instructions, etc.

[0103] The entire instruction architecture is shown in Figure 3. Instructions are encapsulated in these modules and added to an execution list. These instructions are then executed in a multi-process loop. The process is as follows:

[0104] The execution process of a single instruction is as follows:

[0105] When a single command is executed, ProcessRunner launches a process to execute the corresponding instruction. If an error occurs in any instruction during the entire process, the simulation process terminates. The simulation is considered successful only if all instructions in the entire process are executed correctly.

[0106] The embodiment of the present application can simplify the operation process. The command line in the present application can be operated by a simple command call, and the user does not need to understand the specific path and parameter settings of the executable file.

[0107] The embodiments of the present application can improve the degree of automation. The present application builds an instruction set architecture suitable for batch processing of processes, and can process multiple processes at a time without manual interaction.

[0108] The present invention improves data accuracy by combining parameters in a command-line format during industrial design simulation. This allows the method to adopt standardized parameter transfer methods, such as command-line parameters or configuration files. This makes it easier to manage and maintain parameter settings and reduces the possibility of data errors.

[0109] The embodiments of the present application are universal. In the industrial design simulation process, the present application combines parameters in the form of command lines. Command line tools are usually cross-platform and can run on different operating systems, which increases the flexibility of the industrial design simulation process and makes it more universal.

[0110] In the description of this application, it should be noted that the terms used herein are only for the purpose of describing specific embodiments and are not intended to limit the exemplary embodiments according to this application. For ease of description, the sizes of the multiple parts shown in the drawings are not drawn according to the actual proportional relationship. The techniques, methods and equipment known to ordinary technicians in the relevant fields may not be discussed in detail, but where appropriate, the techniques, methods and equipment should be considered as part of the authorization specification. In all examples shown and discussed here, any specific values ​​should be interpreted as merely exemplary and not as limitations. Therefore, other examples of the exemplary embodiments may have different values. It should be noted that similar numbers and letters represent similar items in the following figures, so once an item is defined in one figure, it does not need to be further discussed in subsequent figures.

[0111] It should be noted that, in this application, the terms "comprises", "includes" or any other variants thereof are intended to cover non-exclusive inclusion, so that a process, method, article or device comprising a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, article or device. It should also be pointed out that the scope of the methods and devices in the embodiments of the present application is not limited to performing functions in the order shown or discussed, and may also include performing functions in a substantially simultaneous manner or in the opposite order according to the functions involved. For example, the described method may be performed in an order different from that described, and multiple steps may be added, omitted, or combined. In addition, features described with reference to certain examples may be combined in other examples.

[0112] The multi-process industrial design software simulation method and device based on the instruction set architecture provided in the embodiment of the present application can be applied to electronic equipment manufacturing, automobile parts production, machining industry, aerospace industry, construction industry, etc. For example, it can be applied to the design and development of industrial products to help designers visualize the appearance and structure of products in the early stages and quickly evaluate the feasibility of different design solutions; or combined with detection equipment to accurately measure and analyze the size, shape, etc. of the product. The multi-process industrial design software simulation method based on the instruction set architecture provided in the embodiment of the present application can be executed by industrial simulation software, which is stored in a computer-readable storage medium. The method can also be executed by a processor or computer device including the above-mentioned industrial simulation software.

Claims

1. A multi-process industrial design software simulation method based on an instruction set architecture, comprising: Building an instruction set architecture, the instruction set architecture including an instruction set base class and an instruction set function module, the instruction set base class is configured to provide a basic interface for instructions, and the instruction set function module is configured to implement specified functions; Decomposing the simulation process into functional units and mapping the instruction set functional modules to the functional units, wherein the functions performed by the functional units are performed by instructions; Encapsulating instructions in the instruction set function module and providing an instruction interface for the instruction set function module, wherein the instructions encapsulated in the instruction set function module correspond to functions implemented by the instruction set function module, and the instruction interface corresponds to a pre-verification function, an instruction parameter splicing function, an instruction execution function, and a post-verification function; The pre-check function, the instruction parameter splicing function, the instruction running function, and the post-check function are executed on the instructions encapsulated in the instruction set functional module through the instruction interface, and the instructions after executing the pre-check function, the instruction parameter splicing function, the instruction running function, and the post-check function are stored in an execution list; during the execution of the simulation process, multiple instructions in the execution list are cyclically executed in a multi-process manner, and a process is started when each instruction is executed.

2. The multi-process industrial design software simulation method based on the instruction set architecture according to claim 1, wherein: Each instruction starts a process when executed, including: Checking whether the parameters input into each instruction are correct and whether the required file exists in the corresponding directory, and in response to determining that the required file does not exist in the corresponding directory, feeding back the checking result to the user; In response to determining that the required file exists in the corresponding directory, combining the parameters required for each instruction in the form of instruction line parameters; Providing an execution function for each instruction to execute the instruction line; Checking whether the output format of the output file after each instruction is executed is correct, and in response to determining that the output format of the output file is correct, outputting the output file, and terminating the execution of the process corresponding to each instruction; The multiple instructions in the execution list are executed cyclically, and the output file of the previous instruction is used as the input file required by the next instruction; In response to determining that the process corresponding to any one instruction fails to execute, the simulation process ends.

3. The multi-process industrial design software simulation method based on instruction set architecture according to claim 2, wherein: The instruction set functional module includes: a verification module, a preparation module, a mesh generation module, and a numerical solution module; the functional unit includes: a pre-processing unit, a mesh generation unit, and a numerical solution unit; wherein, mapping the instruction set functional module with the functional unit includes: The pre-processing unit corresponds to the verification module and the preparation module, the grid generation unit corresponds to the grid generation module, and the numerical solution unit corresponds to the numerical solution module.

4. The multi-process industrial design software simulation method based on instruction set architecture according to claim 3, wherein: The instructions encapsulated by the verification module include: Verify that material property instructions are assigned to all models; Check whether the priority instructions for using materials are set for the overlapping areas of the model; Check whether the air box is set as the solution domain instruction; Verify that the boundary conditions and excitations are set correctly; Verify that the parameters for generating the mesh are set correctly; and Check whether the step size and solution time of the numerical solution are set as instructed.

5. The multi-process industrial design software simulation method based on instruction set architecture according to claim 3, wherein: The instructions encapsulated by the preparation module include: writing model instructions, material file instructions, boundary condition instructions and excitation instructions.

6. The multi-process industrial design software simulation method based on instruction set architecture according to claim 3, wherein: The instructions encapsulated by the grid generation module include slicing instructions, grid generation instructions, and encryption optimization instructions.

7. The multi-process industrial design software simulation method based on instruction set architecture according to claim 3, wherein: The instructions encapsulated in the numerical solution module include: thermodynamic solution instructions, electromagnetic solution instructions, stress solution instructions and fluid solution instructions.

8. A multi-process industrial design software simulation device based on an instruction set architecture, comprising a memory, a processor, and a computer program stored in the memory. When executing the computer program, the processor implements the multi-process industrial design software simulation method based on the instruction set architecture as described in any one of claims 1 to 7.

9. A computer-readable medium having a computer program stored thereon, wherein when the computer program is executed by a processor, the multi-process industrial design software simulation method based on an instruction set architecture as described in any one of claims 1 to 7 is implemented.

10. A computer program product, comprising a computer program, wherein when the computer program is executed by a processor, the computer program implements the multi-process industrial design software simulation method based on an instruction set architecture as described in any one of claims 1 to 7.

Images