A multi-software package running method, computer program product and terminal device

Abstract

The application belongs to a software packaging method, and aims at solving the technical problems that in the current traditional complex product development mode, each tool software needs to be configured by relevant professionals for operation, the work efficiency is low, the work difficulty is high, and the design scheme is difficult to be comprehensively optimized, providing a multi-software packaging operation method, a computer program product and a terminal device, multiple software is packaged respectively to obtain multiple corresponding components, a simulation process is formed, the input and output of each component in the simulation process are structured and saved in a parameterJson file, a mapping relationship between the input and output of each component is constructed and stored in a mappingJson file, according to the mapping relationship, the data obtained by parsing the result file after execution is written into the file relied on by the next component to be executed, and a simulation process of data flow between different components is formed.

Description

Technical Field

[0001] This invention pertains to software packaging methods, specifically relating to a multi-software packaging and operation method, computer program products, and terminal devices. Background Technology

[0002] Traditional complex product development models typically involve multiple levels, including overall design, subsystems, and components, and encompass multiple disciplines such as fluid dynamics, structure, control, and information. They require extensive comparison of solutions and multiple design cycles, progressing from simple to complex, based on the interrelationships and constraints between subsystems and disciplines, to complete the design. Therefore, current design methods suffer from being discrete, isolated, and unsystematic. The design process is not standardized, software tools are not integrated, data flow is not streamlined, and there are no design rules or methodologies to guide each stage of the design process, resulting in a significant amount of repetitive manual labor.

[0003] Because the application of specialized software resembles a workshop model, using multiple software tools involves complex processes for each tool, resulting in low efficiency, high personnel requirements, and limited software sharing, thus hindering the full realization of their value. Without integration, the design phases of each tool require personnel from different disciplines, and the calculation results of each work node must be manually processed before being passed to the next. This approach often impacts the efficiency and complexity of each work node and carries the risk of errors from one node being carried over to the next, compromising the accuracy of product development results.

[0004] Furthermore, due to the isolation of commercial software interfaces and data, development experience between products cannot be replicated or referenced, easily leading to repeated development of functions and failing to effectively guarantee the efficiency and quality of development work. The relationships between the design models of various disciplines are loose and lack correlation, resulting in a large workload for scheme changes and design coordination, making it difficult to achieve rapid design iteration across disciplines and to comprehensively optimize design schemes. Summary of the Invention

[0005] This invention addresses the challenges of traditional complex product development models, which require the use of multiple software tools. These tools are not integrated, necessitating specialized personnel to operate each tool and process the calculations at each corresponding work node. This results in low efficiency, high complexity, and compromised accuracy of product development outcomes. Furthermore, the workload for scheme changes and design coordination is substantial, hindering rapid design iteration across disciplines and comprehensive optimization of design schemes. The invention provides a multi-software encapsulation and operation method, a computer program product, and a terminal device.

[0006] To achieve the above objectives, the present invention provides the following technical solution:

[0007] A multi-software encapsulation and execution method, characterized by the following steps:

[0008] S1, Constructing the simulation process

[0009] Multiple software programs are packaged separately to obtain multiple corresponding components. These components are then connected into a process according to a specified logical order to form a simulation process.

[0010] S2, Construct the mapping relationship of parameters of each component in the simulation process.

[0011] S2.1 Define the inputs and outputs of each component in the simulation process according to the XML standard, form a structured management, and store it in the parameterJson file;

[0012] The input includes an input file and input data, and the output includes an output file and output data;

[0013] S2.2, Based on XML, construct the mapping relationship between the inputs and outputs of each component, and store the mapping relationship in the mappingJson file;

[0014] S3 executes the simulation task and outputs the simulation results.

[0015] S3.1, Based on the task requirements, construct the input required for operation, execute any component based on the input, and save the output of the component after execution in a structured way, storing it in the parameterJson file;

[0016] S3.2, parse the mappingJson file to obtain the mapping relationship, and then parse the parameterJson file to obtain the input required for the next component to execute in the specified logical order, as well as the output of the previous component;

[0017] The component is executed by replacing the input of the next component with the output of the previous component, and the output after execution is saved in a structured format in a parameterJson file.

[0018] Alternatively, adjust some or all of the inputs for the next component to execute, and save the output in a structured format in a parameterJson file.

[0019] S3.3 Repeat step S3.2 until the last component in the simulation process is executed. Parse the parameterJson file to obtain the output of the last component after execution, which is used as the simulation result of the task execution.

[0020] Furthermore, the execution of any component in step S3.1 and the execution of the component in step S3.2 are both controlled by bat and shell commands to start the component.

[0021] Furthermore, the specific steps of controlling the startup of the component via batch and shell commands are as follows:

[0022] The commands for calling each component, the file paths required for each component to execute, and the execution methods for each component are written using the cmd command. All commands are then encapsulated in a batch file. The batch file is executed via a process, and the commands in the batch file are run to trigger the startup of each component.

[0023] Furthermore, the multiple software programs mentioned in step S1 include UG, ICEM, CFX, Ansys, Fluent, and ABAQUS.

[0024] Furthermore, the process of packaging multiple software programs separately, specifically the packaging of UG, involves:

[0025] Configure environment variables, select the prt file, read the prt file to obtain the data used as parameter variables, mark the data used as parameter variables, replace the marked parameter variable data with GUID, update the prt file, structure the data of the parameter variables before replacing them with GUID and the GUID, and store the structured result in the parameterJson file.

[0026] Furthermore, the process of packaging multiple software programs separately, with ICEM specifically packaged as follows:

[0027] Configure environment variables, select the rpl file, parse the rpl file data using a text editor, perform matrix analysis on the parsed rpl file data, record the length of each character in each line, and store it in the parameterJson file.

[0028] Further, the execution of any component in step S3.1 and the execution of that component in step S3.2, wherein executing the UG component specifically refers to:

[0029] Obtain the input of the UG component based on the parameterJson and mappingJson files, replace the GUID in the prt file, and run the prt file.

[0030] Further, the execution of any component in step S3.1 and the execution of that component in step S3.2, wherein the execution of the ICEM component specifically refers to:

[0031] The input of the UG component is obtained from the parameterJson file and the mappingJson file. Then, the position of the rpl file is located according to the row, start position and parameter variable length of the obtained input. The replacement is performed one by one to generate a replacement rpl file. The replacement rpl file is then run.

[0032] The present invention also provides a computer program product, including a computer program, characterized in that the program, when executed by a processor, implements the steps of the above-described method.

[0033] In addition, the present invention also provides a terminal device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the steps of the method described above.

[0034] Compared with the prior art, the beneficial effects of the present invention are:

[0035] 1. This invention provides a multi-software encapsulation and execution method that connects multiple software programs in a logical sequence into a single process for handling a specific type of problem. The method encapsulates each software program and establishes mapping relationships between the components, enabling each program to automatically execute and output task results. In use, the user only needs to input the task requirements to start the simulation process from any component. The output of each component after execution can be used as input for the next component in the simulation process, based on the mapping relationships, thus initiating the next component's execution.

[0036] 2. This invention can be applied to complex product development models where multiple software tools are required for design. The method of this invention constructs a standardized interface control mechanism and creates a simulation running environment by sorting out the relationships between multiple components, thereby solving the problem of interface and data isolation between multiple software programs.

[0037] 3. The method of the present invention can add software to the existing simulation process according to actual usage needs. Only the simulation process and mapping relationship need to be adjusted, which makes it highly flexible.

[0038] 4. In the process of each simulation component execution, the user can also adjust the input file of the next component according to the output file of the previous component, and intervene in the software operation in a timely manner as needed, providing a flexible operation method. Detailed Implementation

[0039] The technical solution of the present invention will be clearly and completely described below with reference to the embodiments of the present invention. Obviously, the described embodiments are not intended to limit the present invention.

[0040] This invention encapsulates multiple software programs, studies the dependencies between them before and after execution, constructs a standardized interface management mechanism, and clarifies the data relationships between the software programs. It links multiple software programs required in the product development process, defines the inputs for each program, collects the corresponding outputs, and automatically transmits the outputs to the next related software program, creating a runtime environment that supports co-simulation. This eliminates the isolation between software interfaces and data.

[0041] The method of this invention will be explained below using relevant software for fluid layout optimization design and fluid characteristic analysis as examples:

[0042] In automated fluid layout optimization design and fluid characteristic analysis, the encapsulated design software includes UG, ICEM, CFX, Ansys, Fluent, and ABAQUS. After encapsulating each software, multiple components corresponding to each software are formed. Each component calls the corresponding software according to the input and parameterized driving script file to obtain the calculation file of unstructured data and the output of structured data. The components are interconnected, and the files and data generated by the components can be seamlessly connected. The files and data generated by the previous component can be automatically passed to the next related component node.

[0043] Each component can flexibly construct an automated fluid layout optimization design and fluid characteristic analysis process. It can automatically carry out shape design, fluid calculation, simulation, and optimization according to the needs of product development, and complete the entire development work of fluidized layout and analysis.

[0044] UG, ICEM, CFX, Ansys, Fluent, and ABAQUS are encapsulated to obtain UG components, ICEM components, CFX components, Ansys components, Fluent components, and ABAQUS components. The simulation components and 3D modeling components are connected into a process according to a certain logical order. This process can realize a simulation calculation, optimization, and design business. This process is called the simulation process.

[0045] The core of simulation workflow construction lies in data transfer between simulation components. Establishing the data relationships between all simulation components and forming a mapping and transfer logic for simulation component data is crucial. The implementation logic for simulation component data transfer is as follows:

[0046] (1) Implement parameterized encapsulation for simulation components. Each simulation component has inputs and outputs.

[0047] It includes input files (files that the simulation component depends on when it is executed) and input data (data that controls the execution of the simulation component). The output includes output data (the results generated by the execution of the simulation component) and output files (files generated after the simulation component is completed).

[0048] (2) The inputs and outputs of the simulation components are persistently and in a structured manner.

[0049] In the parameterJson file;

[0050] (3) Construct the mapping relationship between the input and output of the simulation components. For example, map the simulation components...

[0051] The output of the UG component is associated with the input of the ICEM simulation component, and the output of the ICEM component is associated with the input of the CFX component, forming a mapping relationship. The mapping relationship is stored in the mappingJson file;

[0052] (4) During execution, any component in the simulation process can be executed as the first simulation component.

[0053] Execution can begin from any component, depending on the task requirements. The execution of the first simulation component is divided into three parts:

[0054] 1) The first part involves constructing the files and data required for the simulation component to run. This involves parsing the parameterJson file to obtain the input files and data for the simulation component, and then constructing the necessary files and data for the simulation component to run.

[0055] 2) The second part involves executing the simulation component. The simulation component is started using batch and shell commands, and its running status is monitored in real time.

[0056] 3) The third part involves obtaining the output files and output data generated after the simulation component is executed, and saving them in a structured format to the parameterJson file for use by the next simulation component.

[0057] (5) The simulation component located in the middle of the simulation process is divided into three parts:

[0058] 1) The first part involves constructing the files and data required for the simulation component to run. The mappingJson file is parsed to obtain the mapping relationship of the simulation component parameters. Then, the parameterJson file is parsed to obtain the input files and input data of the simulation component, as well as the output files and outputs of the previous simulation component in the mapping relationship. This process is used to construct the files and data required for the simulation component to run.

[0059] 2) The second part involves executing the simulation component. The simulation component is started using batch and shell commands, and its running status is monitored in real time.

[0060] 3) The third part involves obtaining the output files and output data generated after the simulation component is executed, and saving them in a structured format to the parameterJson file for use by the next simulation component.

[0061] (6) The execution of the last simulation component in the simulation process is divided into three parts:

[0062] 1) The first part involves constructing the files and data required for the simulation component to run. The mappingJson file is parsed to obtain the mapping relationship of the simulation component parameters. Then, the parameterJson file is parsed to obtain the input files and input data of the simulation component, as well as the output files and outputs of the mapped previous simulation component. This process completes the construction of the files and data required for the simulation component to run.

[0063] 2) The second part involves executing the simulation component. The simulation component is started using batch and shell commands, and its running status is monitored in real time.

[0064] 3) The third part is to obtain the output files and output data generated after the simulation component is executed, and save them in a structured format to the parameterJson file as the output result of the simulation process.

[0065] (7) After the simulation process is completed, the parameterJson file is parsed and the output file and output data of the last simulation component are displayed to the user.

[0066] During the simulation process, the output files and output data of each simulation component can also be displayed and viewed.

[0067] Each software needs to be parametrically packaged before it can be used as a simulation component in the simulation process. The packaged simulation components all have standard input and output formats. Below are the packaging methods for UG and ICEM software, the execution methods for UG and ICEM components, and the outputs of UG and ICEM components:

[0068] UG software is an interactive CAD / CAM (Computer-Aided Design and Computer-Aided Manufacturing) tool that enables the construction of various complex solids and shapes, and is a mainstream application for 3D design in the mold industry. This software implements parametric encapsulation of UG, allowing the UG simulation component to invoke UG, read the parametric driven model and inputs, perform calculations, and output the result file.

[0069] 1. The encapsulation logic of the UG simulation component is as follows:

[0070] (1) Configure environment variables. When cmd and shell call UG software to execute, environment variables need to be introduced. Environment variables are the core input data of UG components;

[0071] (2) Select the prt file. The prt file is a model file generated by UG secondary development. It is mainly developed by software engineers using C++ language or recorded by UG according to business needs. The prt file is a model file that is necessary for UG to run.

[0072] (3) Parametric model file. The prt file is a parametric model file. We read the prt file, get the data in the prt file as parameter variables, mark the parameter variable data, use GUID to replace the parameter data, and update the prt file.

[0073] (4) Model parameter extraction: When parameterizing the model file in the previous step, the parameter variables and GUIDs of the replacement parameter variables in the prt file were obtained. The parameter variables and GUIDs were structured and stored in parameterJson.

[0074] 2. Execution of UG simulation components:

[0075] (1) Obtain the input of UG components based on the mappingJson file and the parameterJson file; (2) Update the prt model file. Take the input obtained in the previous step, loop through it, and gradually replace the GUID in the prt model file. Change the GUID to the latest parameter data.

[0076] (3) Construct the command to execute UG, use the environment variables in the input and the specific UG startup command to run the prt model file, and the UG software will run silently in the background automatically;

[0077] (4) Result generation: After the UG software finishes execution, it will automatically close and generate the latest 3D model wrl file. At the same time, the UG component monitors the end of the UG software process and executes the next operation.

[0078] 3. Output encapsulation: After the UG software finishes execution, the UG component will encapsulate the generated results to prepare for the next simulation component in the simulation process. Output encapsulation includes the following aspects:

[0079] (1) Save the wrl model file generated by UG software and the updated prt model file, and save the path to the parameterJson file.

[0080] (2) The WRL model file can be directly displayed on the program interface as the display result of the model;

[0081] (3) The execution of the UG component ends.

[0082] ICEM is a professional pre-processing software that provides efficient and reliable analysis models for CAE software. It boasts powerful CAD model repair capabilities, automatic mid-surface extraction, unique mesh "sculpting" technology, mesh editing technology, and broad solver support. The ICEM component calls the local or remote ICEM software to perform mesh generation and editing based on specified parameter or script files, outputting result files and mesh quality result files.

[0083] The ICEM software is parametrically encapsulated. The ICEM simulation component invokes the ICEM software, reads the parametric mesh script and input, performs calculations, and outputs the result file.

[0084] 1. The encapsulation logic of the ICEM simulation component is as follows:

[0085] (1) Input encapsulation: The input of the ICEM simulation component mainly includes the following aspects:

[0086] (2) Configure environment variables. When cmd and shell call UG software to execute, environment variables need to be introduced. Environment variables are the core input data of ICEM components.

[0087] (3) Select the rpl file. rpl is a parametric meshing script, which is usually a mesh script file written by CAE project according to business needs or recorded using ICEM software.

[0088] (4) Parameter extraction: Use a text editor to parse the data in the rpl file and perform matrix analysis on the data. CAE engineers can record the Nth row, the Sth character, and the Lth length of the parameter data in the rpl. The recorded data is stored in the parameterJson file.

[0089] (5) ICEM components are usually used as simulation process components after UG components, and their parameter mapping needs to be associated with multiple parameters of UG components.

[0090] 2. ICEM component execution, which includes the following aspects:

[0091] (1) Obtain the input of the ICEM component based on the mappingJson file and the parameterJson file;

[0092] (2) Update the rpl mesh script. Based on the input obtained in the previous step, accurately locate the position of the rpl mesh script parameter variables according to the line, start position and length of the parameter variables, replace them one by one, and finally change it to the latest mesh script.

[0093] (3) Construct the command to execute ICEM, use the environment variables and specific ICEM startup commands in the input to run the rpl file, and the ICEM software will run silently in the background automatically;

[0094] (3) Generate results. After the ICEM software finishes execution, it will automatically close, generating the latest mesh file rpl and mesh quality result file. At the same time, the ICEM component monitors the end of the ICEM software process and executes the next operation.

[0095] 3. Output encapsulation: After the ICEM software completes execution, the ICEM component encapsulates the generated results to prepare for the next simulation component in the simulation flow. Output encapsulation includes the following aspects:

[0096] (1) Save the latest mesh file rpl and mesh quality file generated by ICEM software, and save the path to the parameterJson file;

[0097] (2) The mesh quality result file can be used as an intermediate product for CAE engineers to check whether the mesh quality meets the standards. It can also be parsed and displayed as a chart on the software interface.

[0098] (3) The ICEM component has finished executing.

[0099] According to the task requirements, when a certain component needs to be called, after the component starts, it reads the data required for execution according to the parameter settings, combines it with the script file, and begins execution. The results are stored in the working path for other components to execute and call. The command to call the component is written using the cmd command, along with the file paths required for component execution and the execution method. This command is encapsulated in a batch file (.bat). The platform executes the batch file as a process, thus running the cmd command within the batch file and triggering the component's execution. After the component completes execution, the result file and temporary intermediate files are saved in the working path. Based on experience, the name of the result file is determined. The platform parses the result file to obtain its data. According to the defined mapping relationship, the data parsed from the executed result file is used as parameters and written to the file that the next component to be executed depends on. The logic of calling components using cmd commands is repeated, thus forming a simulation process that connects the data flow between different components.

[0100] It should be noted that the above is only an example of fluid design and characteristic analysis software to illustrate the method of the present invention. The method of the present invention can also be applied to any other related fields, as long as there is a logical relationship between the multiple software programs.

[0101] Especially for encapsulating general-purpose industrial design software, the method of this invention is convenient and efficient. It can encapsulate multidisciplinary industrial design software, construct industrial design simulation processes, analyze parametric modeling methods in various industrial design software, and encapsulate multiple types of multidisciplinary industrial software to obtain multiple corresponding components. These components possess standard and unified calling interfaces for startup files, input files, output files, and outputs. Before performing calculations, the industrial design software parses the correspondence between the startup file and the input to obtain the actual running parameters and performs calculations in conjunction with the startup file. After the industrial design software completes the calculations, the results are stored in the output file. By parsing the correspondence between the output file and the output, the calculated parameter results are obtained. Multiple components are connected into a process according to a customizable and flexible specified logical order, forming a process that meets the simulation needs of multidisciplinary and multi-model products in industrial design.

[0102] In addition, in the method of the present invention, when the simulation component located in the middle of the simulation process is executed, the mappingJson file is parsed to obtain the mapping relationship, and then the parameterJson file is parsed to obtain the input required for the execution of the next component in the specified logical order, as well as the output of the previous component. At this time, the user can also manually adjust the input for the execution of the next component. In this case, the simulation component is executed according to the last received input.

[0103] Furthermore, the packaging method of the present invention can also be applied to terminal devices. A terminal device includes a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, it implements the steps of the fusion method of the present invention. The terminal device here can be a computer, laptop, handheld computer, or various cloud servers, etc., and the processor can be a general-purpose processor, digital signal processor, application-specific integrated circuit, or other programmable logic device.

[0104] The packaging and execution method of the present invention can also be used as a computer program product, including a computer program that implements the steps of the above-described packaging and execution method when the program is executed by a processor.

[0105] The above description is merely an embodiment of the present invention and is not intended to limit the scope of protection of the present invention. Any equivalent structural transformations made using the present invention specification, or direct or indirect applications in other related technical fields, are included within the patent protection scope of the present invention.

Claims

1. A method for running multiple software packages, characterized in that, Includes the following steps: S1, Constructing the simulation process Multiple software programs are packaged separately to obtain multiple corresponding components. These components are then connected into a process according to a specified logical order to form a simulation process. S2, Construct the mapping relationship of parameters of each component in the simulation process. S2.1 Define the inputs and outputs of each component in the simulation process according to the XML standard, form a structured management system, and store it in a parameterJson file; wherein, the input includes input files and input data, and the output includes output files and output data; S2.2, Based on XML, construct the mapping relationship between the inputs and outputs of each component, and store the mapping relationship in the mappingJson file; S3 executes the simulation task and outputs the simulation results. S3.1, Based on the task requirements, construct the input required for operation, execute any component based on the input, and save the output of the component after execution in a structured way, storing it in the parameterJson file; S3.2, parse the mappingJson file to obtain the mapping relationship, and then parse the parameterJson file to obtain the input required for the next component to execute in the specified logical order, as well as the output of the previous component; The component is executed by replacing the input of the next component with the output of the previous component, and the output after execution is saved in a structured format in a parameterJson file. Alternatively, adjust some or all of the inputs for the next component to execute, and save the output in a structured format in a parameterJson file. S3.3 Repeat step S3.2 until the last component in the simulation process is executed. Parse the parameterJson file to obtain the output of the last component after execution, which is used as the simulation result of the task execution.

2. The multi-software encapsulation and operation method as described in claim 1, characterized in that, The execution of any component in step S3.1 and the execution of the component in step S3.2 are both controlled by bat and shell commands to start the component.

3. The multi-software encapsulation and operation method as described in claim 2, characterized in that, The specific steps for controlling the startup of the component via batch and shell commands are as follows: The commands for calling each component, the file paths required for each component to execute, and the execution methods for each component are written using the cmd command. All commands are then encapsulated in a batch file. The batch file is executed via a process, and the commands in the batch file are run to trigger the startup of each component.

4. A multi-software encapsulation and operation method as described in any one of claims 1 to 3, characterized in that, The multiple software programs mentioned in step S1 include UG, ICEM, CFX, Ansys, Fluent, and ABAQUS.

5. The multi-software encapsulation and operation method as described in claim 4, characterized in that, In step S1, the multiple software programs are packaged separately, wherein the packaging of UG is specifically as follows: Configure environment variables, select the prt file, read the prt file to obtain the data used as parameter variables, mark the data used as parameter variables, replace the marked parameter variable data with GUID, update the prt file, structure the data of the parameter variables before replacing them with GUID and the GUID, and store the structured result in the parameterJson file.

6. The multi-software encapsulation and operation method as described in claim 5, characterized in that, In step S1, the multiple software programs are packaged separately, wherein the packaging of ICEM specifically involves: Configure environment variables, select the rpl file, parse the rpl file data using a text editor, perform matrix analysis on the parsed rpl file data, record the length of each character in each line, and store it in the parameterJson file.

7. The multi-software encapsulation and operation method as described in claim 6, characterized in that, The execution of any component as described in step S3.1 and the execution of that component as described in step S3.2, wherein the execution of the UG component specifically refers to: Obtain the input of the UG component based on the parameterJson and mappingJson files, replace the GUID in the prt file, and run the prt file.

8. The multi-software encapsulation and operation method as described in claim 6, characterized in that, The execution of any component as described in step S3.1 and the execution of that component as described in step S3.2, wherein the execution of the ICEM component specifically refers to: The input of the UG component is obtained from the parameterJson file and the mappingJson file. Then, the position of the rpl file is located according to the row, start position and parameter variable length of the obtained input. The replacement is performed one by one to generate a replacement rpl file. The replacement rpl file is then run.

9. A computer program product, comprising a computer program, characterized in that: When the program is executed by the processor, it implements the steps of the method according to any one of claims 1 to 8.

10. A terminal device, comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that: When the processor executes the computer program, it implements the steps of the method as described in any one of claims 1 to 8.