CAE software-oriented general application program base design method and CAE software-oriented general application program base design system

Abstract

The invention discloses a CAE software-oriented universal application program base design method and system, and relates to the field of CAE software design. The method and the device are used for solving the problem that existing CAE software-oriented general application program base design does not have a software integration standard system and a technical route for multiple subsystems of multiple software temporarily. The method comprises the following steps: dividing a universal application program base into a longitudinal operation process and a transverse operation process; the longitudinal operation process is divided into registration, initialization, event circulation and memory release; the transverse operation process is divided into application program architecture, global data, component management, a signal adapter, a program driving manager, UI time processing, main interface generation, a global data factory, a component factory, software setting, a command line processor, a signal processor, an event processor and a Python registration interface. The method is suitable for CAE software-oriented universal application program base design.

Description

Technical Field

[0001] The present invention relates to the field of CAE software design, and in particular to a design method for a universal application base for CAE software. Background Art

[0002] CAE software is a powerful tool that is widely used in many fields such as automobiles, aerospace, electronics, and machinery to simulate and analyze the physical behavior of products in order to predict their performance, reliability, and durability.

[0003] There are many technical solutions for the universal application base for CAE software, which are designed to provide a stable, efficient and scalable platform to support the development, operation and optimization of CAE software. The following are some of the main technical solutions and their characteristics: 1. Standardization and systematization process customization: According to a specific application scenario and application software, a specific standardized process system is developed to encapsulate specific business logic and operation scenarios, improve work efficiency, and reduce the probability of errors caused by manual participation. 2. Cloud computing platform: The cloud computing platform can install multiple software on a unified platform, and access multiple software through cloud desktop or browser login, which improves the convenience and efficiency of CAE software and reduces the hardware cost of users. 3: CAD / CAE integrated integration technology, through CAD software (such as UG) to establish a three-dimensional model of the product, and convert it into a format suitable for CAE software import, and use CAE software to mesh the three-dimensional model. The integrated application of CAD / CAE technology realizes the integration of design, analysis, and manufacturing processes, and improves the efficiency and quality of design.

[0004] The above-mentioned general application base design solutions and systems for CAE software are partly customized for specific application scenarios of specific software, and partly only provide a broad software operating environment, and each software runs independently. The current technical solution does not yet address the issue of software integration standard system and technical route for multiple subsystems of multiple software. Summary of the invention

[0005] The present invention is used to solve the problem that the existing general application base design for CAE software has no software integration standard system and technical route for multiple subsystems of multiple software.

[0006] To achieve the above object, the present invention provides the following technical solutions:

[0007] The present invention provides a CAE software-oriented universal application base design method, the method comprising the following steps:

[0008] Step S1: Divide the universal application base into a vertical operation process and a horizontal operation process;

[0009] Step S2: The vertical operation process is divided into registration, initialization, event loop and memory release;

[0010] Step S3: The horizontal operation process is divided into application architecture, global data, component management, signal adapter, program driver manager, UI time processing, main interface generation, global data factory, component factory, software settings, command line processor, signal processor, event processor and Python registration interface.

[0011] Furthermore, there is a preferred embodiment, the above registration is used to implement the creation and registration of the data creator and the event handler;

[0012] The above initialization is used to perform initialization operations on registered objects and create various global data objects;

[0013] The above event loop is used to process complex business process events based on user interactions;

[0014] The above memory release is used to recycle and release memory after the process ends.

[0015] Furthermore, in a preferred embodiment, the above application architecture is used to provide a registration interface for factories and event processing;

[0016] The above global data is used to manage global data;

[0017] The above component management is used to manage the generated components and provide access interfaces;

[0018] The above signal adapter is used to realize signal forwarding between components, including console information and thread running progress;

[0019] The program driver manager is used to start and terminate third-party applications to achieve process-level integration;

[0020] The above UI time processing is used to implement global event response;

[0021] The above main interface generation is used to load qss and translation files while generating the main interface;

[0022] The above global data factory is used to generate global data and put it into global data for management;

[0023] The above component factory is used to create components and put them into the component manager;

[0024] The above software settings are used to set when the software is running, and can read and write INI files;

[0025] The above command line processor is used to process command line parameters;

[0026] The signal processor is used to perform personalized signal processing;

[0027] The above event processor is used to perform personalized event processing;

[0028] The above Python registration interface is used to implement Python calls.

[0029] Furthermore, there is a preferred embodiment that defines the above application architecture based on QApplication.

[0030] Furthermore, in a preferred embodiment, the global data includes geometric data, mesh data, physical model data and post-processing data.

[0031] Furthermore, in a preferred embodiment, the above-mentioned global event response includes keyboard and mouse events and registrable event handlers.

[0032] Furthermore, there is a preferred embodiment in which the universal application base proposed in the present invention can be used for the integration of various CAE software and their subsystems.

[0033] The method for designing a universal application base for CAE software described in the present invention can be implemented entirely by computer software. Therefore, correspondingly, the present invention also provides a universal application base design system for CAE software, the system comprising a storage device for executing the following steps:

[0034] Step S1: Divide the universal application base into a vertical operation process and a horizontal operation process;

[0035] Step S2: The vertical operation process is divided into registration, initialization, event loop and memory release;

[0036] Step S3: The horizontal operation process is divided into application architecture, global data, component management, signal adapter, program driver manager, UI time processing, main interface generation, global data factory, component factory, software settings, command line processor, signal processor, event processor and Python registration interface.

[0037] The present invention also provides a computer-readable storage medium having a computer program stored thereon. When the computer program is executed by a processor, any one of the above-mentioned methods for designing a universal application base for CAE software is implemented.

[0038] The present invention also provides a computer device, which includes a memory and a processor, wherein the memory stores a computer program, and when the processor runs the computer program stored in the memory, the processor executes any one of the above-mentioned methods for designing a general application base for CAE software.

[0039] The beneficial effects of the present invention are:

[0040] The present invention provides a method for designing a universal application base for CAE software. The designed universal application base is applied to the CAE software development process. As a supporting platform for CAE software, the following can be achieved: 1. Providing a unified integrated environment. CAE software involves subsystems and subroutines in multiple disciplines and fields. The base can integrate subsystems and subroutines of different CAE software into a unified platform, which is convenient for terminal users to complete multiple analysis tasks under the same interface and improve work efficiency. 2. Realizing data sharing and data exchange. Through the base, data between different CAE systems can be easily shared and exchanged, avoiding the problems of data format conversion and repeated modeling. 3. Through the base, data between different CAE software can be easily shared and exchanged, avoiding the problems of data format conversion and repeated modeling. 4. For engineering problems in different fields (such as TV base force analysis, LCD base mold design, etc.), the base can provide customized solutions to meet the specific needs of users.

[0041] The present invention is applicable to the design of a universal application base for CAE software. BRIEF DESCRIPTION OF THE DRAWINGS

[0042] In order to more clearly illustrate the specific implementation methods of the present invention or the technical solutions in the prior art, the drawings required for use in the specific implementation methods or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are some implementation methods of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative work.

[0043] Figure 1 It is a structural block diagram of the universal application base for CAE software described in the present invention;

[0044] Figure 2 The registration process of the present invention is implemented through the main function program diagram;

[0045] Figure 3 It is an operation program diagram realized by the main function of the CAE software described in the present invention. DETAILED DESCRIPTION

[0046] In the following description, specific details such as specific system structures and technologies are provided for the purpose of illustration rather than limitation, so as to provide a thorough understanding of the embodiments of the present application. However, it should be clear to those skilled in the art that the present application may also be implemented in other embodiments without these specific details. In other cases, detailed descriptions of well-known systems, devices, circuits, and methods are omitted to prevent unnecessary details from obstructing the description of the present application.

[0047] The specific embodiments of the present invention are further described in detail below in conjunction with the accompanying drawings. The following embodiments will help those skilled in the art to further understand the present invention, but do not limit the present invention in any form. It should be noted that, for those of ordinary skill in the art, several changes and improvements can be made without departing from the concept of the present invention, which all belong to the protection scope of the present invention.

[0048] Implementation method 1, see Figure 1 This embodiment is described. This embodiment aims at the problem that the existing general application base design for CAE software has no software integration standard system and technical route for multiple subsystems of multiple software. Therefore, a general application base design method for CAE software is proposed, so that other functional components can be inserted into the application base designed in this embodiment to realize specific functions.

[0049] The design method includes the following steps:

[0050] Step S1: Divide the universal application base into a vertical operation process and a horizontal operation process;

[0051] Step S2: The vertical operation process is divided into registration, initialization, event loop and memory release;

[0052] Step S3: The horizontal operation process is divided into application architecture, global data, component management, signal adapter, program driver manager, UI time processing, main interface generation, global data factory, component factory, software settings, command line processor, signal processor, event processor and Python registration interface.

[0053] In actual application, this embodiment divides CAE software according to functions and operation processes, specifically into several processes including geometric model processing, meshing, physical modeling, solution calculation and post-processing. The above processes and functions can be divided into different components, and specific functions can be realized through different components. Specifically, other functional components can be inserted into the application base designed in this embodiment to realize specific functions.

[0054] The general application base is written in C++ and is based on a unified abstract interface and registration mechanism to achieve complete independence of business logic and function implementation, supporting convenient function combination and personalized business logic expansion. The application base is designed vertically and horizontally, such as Figure 1 As shown in the figure, the vertical operation process of the application base is divided into four processes: registration, initialization, event loop and memory release. The application base is divided into 14 key parts horizontally, which are implemented by 14 C++ classes, including application architecture, global data, component management, signal adapter, program driver manager, UI time processing, main interface generation, global data factory, component factory, software settings, command line processor, signal processor, event processor and Python registration interface.

[0055] Implementation method 2: This implementation method specifically describes the design method of a general application base for CAE software described in the above implementation method 1;

[0056] The vertical operation process of the program base is divided into registration, initialization, event loop and memory release;

[0057] The registration process creates and registers data creators and event handlers; the initialization process performs initialization operations on registered objects and creates a variety of global data objects; the event loop refers to the processing of complex business process events based on user interactions. Memory release refers to the end of the main process of the software, recycling and releasing memory.

[0058] The application base is divided horizontally into 14 key parts, which are implemented through 14 C++ classes, including application architecture, global data, component management, signal adapter, program driver manager, UI time processing, main interface generation, global data factory, component factory, software settings, command line processor, signal processor, event processor and Python registration interface.

[0059] Among them, the 14 horizontal parts are shown in Table 1 below:

[0060] Application framework (FITKApplication), based on QApplication, defines the main process of software operation. It is used to provide registration interfaces for factories and event processing.

[0061] Global data (FITKGlobalData) is used for global data management, including management of global data such as geometry data, mesh data, physical model data and post-processing data.

[0062] Component management (FITKCmponents) is used for component management, including management of generated components and providing access interfaces.

[0063] The signal adapter (FITKSignalTransfer) is used for signal forwarding between a small number of components, including console information, thread running progress, etc. It can register signal processors to implement personalized signal processing.

[0064] Program Driver Manager (FITKProgramTaskManager) is used to manage third-party program drivers, start and terminate third-party applications, and achieve process-level integration.

[0065] UI event processing (FITKGlobalEventFilter) is used for global event response, including keyboard and mouse events, etc. Event handlers can be registered to implement personalized event processing.

[0066] Main interface generation (FITKAbstractMainwindowGenerator), an abstract class, is used to generate the main interface and load qss and translation files.

[0067] The global data factory (FITKAbstractGlobalDataFactory) is used to generate global data and put it into global data for management. It needs to derive a subclass and register it to FITKApplication.

[0068] The component factory (FITKComponentFactory) is used to create components and put them into the component manager. Subclasses need to be derived and registered with FITKApplication.

[0069] Software settings (FITKAppSettings) are used to set the software when it is running. They can read and write INI files, and can derive subclasses and register them to FITKApplication.

[0070] The command line processor (FITKCommandLineHandler) is used to process command line parameters and can be derived and registered to FITKApplication.

[0071] Signal processor (FITKSignalTransfer), used for personalized signal processing, can be registered to the signal FITKSignalTransfer, the slot function naming format is "on_ <signal>" can automatically associate the signal in FITKSignalTransfer.

[0072] The event processor (FITKAbstractEventFilter) is used to implement a personalized event processor, which can be registered to FITKGlobalEventFilter by deriving a subclass.

[0073] Python registration interface (FITKAbstractPythonRegister) is used to register C++ class decoration to PythonQt, which can realize Python call and needs to derive a subclass to register to FITKApplication.

[0074] Table 1

[0075]

[0076]

[0077]

[0078]

[0079] Implementation method three, see Figure 2 and Figure 3 This embodiment is described. This embodiment specifically describes the operation process of the universal application base designed in the above embodiment.

[0080] The operation process of the application software framework can be divided into several steps: registration, initialization, command execution, message event processing, data persistence, and memory release. Among them, the registration step is the key step in determining the software's form and business functions, and the other parts are all executed autonomously by the framework.

[0081] Among them, the registration process means that some classes need to rewrite the virtual functions based on the base class, and then register them in the specified location. In the subsequent program running process, the software framework will actively call the virtual functions in the corresponding position to perform these personalized operations. Objects that need to be registered are divided into two categories. One category must inherit from the base class to rewrite the virtual functions and then register them in the framework. They are mainly the three classes of FITKAbstractMainwindowGenerator, FITKAbstractGlobalDataFactory, and FITKComponentFactory. The other category can be registered according to specific business needs. For example, if you do not need to process the command line parameters, you do not need to register FITKCommandLineHandler. The registration process is generally implemented in the main function. For example, Figure 2 shown.

[0082] The initialization process refers to operations such as creating data objects and UI objects necessary for software operation, reading configuration files, etc. Initialization is the basis for subsequent execution of commands and processing of message events. The initialization process is roughly as follows. Operations marked with * are operations that will definitely be executed. Other operations will not be executed if there is no registered object.

[0083] (1) Read the software configuration INI file [FITKAppSettings]

[0084] (2) *Generate global data and store it in the global data manager (FITKGlobalData). [FITKAbstractGlobalDataFactory]

[0085] (3) * Load the qss page style file and bilingual file.

FITKAbstractMainwindowGenerator

[0086] (4) * Load and create components and store them in the component management class (FITKComponentFactory).

[0087] (5)*If "-nogui" is present in the command line, it is considered to be running without an interface, the initialization process ends, and the command execution phase begins.

FITKApplication

[0088] (6) * Generate the main interface of the software and store the main interface pointer in the global data (FITKGlobalData).

FITKAbstractMainwindowGenerator

[0089] (7) * Render the initial UI of the main interface.

FITKApplication

[0090] (8) Register the Python decorator. [FITKAbstractPythonRegister]

[0091] (9) Start the autosaver.

FITKApplication

[0092] The command execution operation refers to the execution of command line parameters and the processing file parameters related to the execution of Workbench. Whether the command line command is executed depends on whether the command line processor is registered and whether the command line parameters are given at runtime. The command will only be executed if both are given. The processing logic related to Workbench is similar. On the one hand, it depends on whether it is driven by Workbench and on the other hand, it depends on whether the processor is registered. It will only be executed if both are given.

[0093] Message events mainly refer to events generated by UI interactions, such as button click events and mouse and keyboard events. These events are mainly executed through some slot functions of the main interface or its sub-interfaces, and mouse and keyboard events can be processed through [FITKAbstractEventFilter]. These events require a high degree of customization.

[0094] Data persistence is performed after the message event ends (usually closing all UIs). Generally speaking, data persistence refers to writing data in memory to files. Most of the functions of data persistence are handled by message events, and the buttons on the UI trigger operations to read and write files. The data persistence mentioned here includes two parts. One part is the writing of software configuration information, which is implemented through FITKAppSettings; the other part is the writing of files required by Workbench.

[0095] Release memory. Memory release is the last step in the life cycle of the software. When releasing memory, first close the thread pool (FITKThreadPool) and terminate all running tasks in the third-party program management (FITKProgramTaskManager), and then release all data in FITKApplication.

[0096] AppFramework is used to divide the horizontal operation process of CAE software into more than a dozen processes, and a series of personalized registration interfaces are provided to realize personalized business. Specifically, CAE software is formed by integrating multiple modules based on the framework.

[0097] First of all, the overall process of AppFramework operation is fixed. First, register the interface class according to business needs, then start the program and execute it in the order of the operation process in the previous part. The registration order has nothing to do with the operation order. The main function of the entire program is as follows Figure 3 As shown in the figure, line 4 is used to create the application framework; lines 8-16 are used to register a series of interface classes; line 19 is used to run the framework. It can be seen that the key to using the framework is to understand how to define the interface class. Each registered interface class will be explained below.

[0098] 1. Application Access Interface (FITKApplication)

[0099] The application FITKApplication is the foundation of the entire software and the general interface for all data access. When the program is running, it is often necessary to access the application object or obtain data from the application object. Some access interfaces are provided in the application as follows:

[0100] The application class inherits from QApplication and can be accessed through QApplication. At the same time, it can be accessed through the quick access macro FITKAPP. The specific main function is:

[0101] 1.#include"FITKApplication.h" 2. / / Get the file directory where the app is located 3. / / FITKAPP is the application object pointer 4.QStringappPath=FITKAPP->applicationDirPath();

[0102] Based on the application framework, you can access some global data, and then search layer by layer to find all valid data objects. This also provides another solution for searching and accessing data objects in addition to the Core module's repository. In addition to the registration function, the commonly used access interfaces are as follows:

[0103]

[0104]

[0105] 2. Main interface generator (FITKAbstractMainwindowGenerator)

[0106] The main function of the main interface generator is to generate the main interface and specify the qss style file and language pack file that need to be loaded. During development, you need to inherit FITKAbstractMainwindowGenerator and rewrite the following functions:

[0107]

[0108]

[0109] The object registration interface is located in FITKApplication:

[0110] 1. / / Register the main interface builder 2.voidregMainWindowGenerator(FITKAbstractMainwindowGenerator*generator);

[0111] Among them, the window object generated by the main interface can be accessed from the global data (FITKGlobalData).

[0112] 3. Global Data Generator (FITKAbstractGlobalDataFactory)

[0113] The global data generator is used to generate global data related to the simulation process, most of which are data management classes, such as mesh data, geometry data, physical model data, etc. When developing a global data generator, you need to inherit the FITKAbstractGlobalDataFactory class and rewrite the following functions. The following functions are not pure virtual functions. If they are not needed in the application, there is no need to rewrite the functions. The examples are as follows:

[0114]

[0115]

[0116] The object registration interface is located in FITKApplication:

[0117] 1. / / Register the main interface builder 2.voidregMainWindowGenerator(FITKAbstractMainwindowGenerator*generator);

[0118] Objects generated by the global data generator can be accessed from the global data (FITKGlobalData).

[0119] 4. Component Generator (FITKComponentFactory)

[0120] Components are an important part of FastCAE. They encapsulate some specific business functions. Component-based software development can achieve function reuse and improve the efficiency of software development and integration. The function of the component generator is to specify the components used in this application and create software handles. When using the component factory, you need to inherit FITKComponentFactory and rewrite the function. The example is as follows:

[0121]

[0122]

[0123] The registration interface of the component generator is located in FITKApplication:

[0124] 1. / / Register component generator 2.voidregComponentsFactory(FITKComponentFactory*fac);

[0125] The component handles generated by the component generator can be accessed from the component manager (FITKCmponents).

[0126] 5. Configuration file reading and writing (FITKAppSettings)

[0127] Configuration file reading and writing means reading the INI configuration file when the software starts, restoring some parameters of the last software run, such as the working path, etc., so that users can have a better and more convenient use experience. At the same time, when the software ends, the required information is synchronously written to the INI file. To use configuration file reading and writing, you need to inherit FITKAppSettings and rewrite the read function. The example is as follows:

[0128]

[0129]

[0130] The registration interface of the configuration file is located in FITKApplication:

[0131] 1. / / Registration configuration file reading 2.voidregAppSettings(FITKAppSettings*settings);

[0132] To read the configuration file, you only need to rewrite the reading function. The writing process is controlled by the framework and directly writes to the path when reading. There is no need to add additional parameters, so there is no need to open the interface.

[0133] 6. Command Line Parameter Processor (FITKCommandLineHandler)

[0134] When the software is started, it is sometimes started through the command line in cmd or Linux terminal. Additional parameters will be given when starting, for example: XXX.exe-ribbon-p abc.pro format. Different application software should have different command line processing logic, so a command line processor expansion interface is provided. When customizing the command line processor, it is required to inherit FITKCommandLineHandler and rewrite the exec function to process the command line parameters. It should be noted that the "nogui" parameter is recognized in the base class, which is considered to be a command that runs without an interface, so no additional processing is required in the subclass. The example is as follows:

[0135]

[0136] The registration interface for the command line processor is located in FITKApplication.

[0137] 1. / / Register command line parameter processor 2.voidregCommandLineHandler(FITKCommandLineHandler*handler);

[0138] 7. Global signal processor (QObject)

[0139] A small number of global signals are defined in the application framework. Global signals are forwarded through FITKSignalTransfer objects. These signals can be processed in different applications. Multiple global signal handlers can be added. The global event handler has two requirements:

[0140] I) It is required to be a subclass of the QObject object and use the Q_OBJECT macro to expand the meta-object;

[0141] II) Name the slot function that needs to be associated with the signal as "on_<signal name>".

[0142] Here is an example:

[0143]

[0144] The on_sendProcessSig slot function in the above code is designed to process the signal sendProcessSig in ITKSignalTransfer. When the object of this class is registered to the application framework, the framework will automatically associate the signal in ITKSignalTransfer according to the "on_<signal name>" rule, without manual association. The registration sample code is as follows:

[0145] 1. / / Create a processor 2.MyThreadTaskProcessHandler*sigH=newMyThreadTaskProcessHandler; 3. / / Add to the application framework, you can add multiple 4.FITKAPP->addGolbalSignalProcesser(sigH);

[0146] 8. Global event handler (FITKAbstractEventFilter)

[0147] Corresponding to the global signal processor processing the global signal (Signal), the global event processor will filter and process the event (QEvent). Since different application software needs to process different events, the method of adding event processors is used to realize personalized processing of different events. Adding event processors requires inheriting FITKAbstractEventFilter and rewriting eventFilter function. The example is as follows:

[0148]

[0149] Add the above object to the application framework, and eventFilter will be automatically called when a message event occurs. Add the sample code as follows:

[0150] 1. / / Create event filter 2.MyMouseKeyEventFilter*evf=newMyMouseKeyEventFilter; 3. / / Add event filter 4.FITKAPP->addEventFilter(evf);

[0151] 9. AutoSaver (FITKAbstractAutoSaver)

[0152] The autosaver is used to automatically save project files, script files, etc. to prevent information loss caused by software crashes. The autosaver uses the timer timeout method to automatically save files at certain intervals. The file autosaver needs to inherit from FITKAbstractAutoSaver and rewrite the autoSave and finalize functions. The example is as follows:

[0153]

[0154]

[0155] The above object is registered in the application framework, and the execution logic of the relevant virtual functions will be automatically called. The registration interface of the automatic saver is located in FITKApplication. The registration code example is as follows:

[0156] 1. / / Initialize the application framework 2.AppFrame::FITKApplicationapp(argc,argv); 3. / / Automatic saving 4.app.regAutoSaver(newAutoSaver);

[0157] 10. System environment check (FITKAbstractSysChecker)

[0158] The system environment check is used to check the software and hardware environment before the software is initialized to determine whether it can meet the basic requirements for the operation of the software. If it cannot meet the basic requirements, an error message will be returned and the program will terminate. When using the system environment check, you need to inherit FITKAbstractSysChecker and rewrite the check function. The example is as follows:

[0159]

[0160]

[0161] The above objects are registered in the application framework, and the execution logic of the relevant virtual functions will be automatically called. The system check usage code example is as follows:

[0162] 1. / / Initialize the application framework 2.AppFrame::FITKApplicationapp(argc,argv); 3. / / System Check 4.app.checkSystem(newSystemChecker);

[0163] Embodiment 4: The method for designing a universal application base for CAE software described in the above embodiment can be implemented entirely by computer software. Therefore, correspondingly, this embodiment provides a universal application base design system for CAE software, the system comprising a storage device for performing the following steps:

[0164] Step S1: Divide the universal application base into a vertical operation process and a horizontal operation process;

[0165] Step S2: The vertical operation process is divided into registration, initialization, event loop and memory release;

[0166] Step S3: The horizontal operation process is divided into application architecture, global data, component management, signal adapter, program driver manager, UI time processing, main interface generation, global data factory, component factory, software settings, command line processor, signal processor, event processor and Python registration interface.

[0167] Implementation method 5: This implementation method provides a computer-readable storage medium on which a computer program is stored. When the computer program is executed by a processor, any one of the above-mentioned methods for designing a universal application base for CAE software is implemented.

[0168] Embodiment 6: The invention provides a computer device, which includes a memory and a processor, wherein the memory stores a computer program, and when the processor runs the computer program stored in the memory, the processor executes any one of the above-mentioned methods for designing a general application base for CAE software.

[0169] A computer device provided in this embodiment, the hardware device of this part is a general model and is not shown in the form of a diagram. The system includes a processor and a memory, wherein the processor and the memory can be connected via a bus or other means. The memory is a non-volatile computer-readable storage medium that can be used to store non-volatile software programs, non-volatile computer executable programs and modules, and corresponding program instructions / modules. The processor executes various functional applications and data processing of the processor by running the non-volatile software programs, instructions and modules stored in the memory, so as to realize a general application base design method and steps for CAE software in the above method embodiment.

[0170] The above description is only the implementation mode of the present invention and is not limited to the present invention. For those skilled in the art, the present invention may have various modifications and variations. Any modification, equivalent substitution, improvement, etc. made within the spirit and principle of the present invention shall be included in the scope of the claims of the present invention.< / signal>

Claims

1. A general application base design method for CAE software, characterized in that: The method is: S1: Divide the universal application base into vertical operation process and horizontal operation process; S2: The vertical operation process is divided into registration, initialization, event loop and memory release; S3: The horizontal operation process is divided into application architecture, global data, component management, signal adapter, program driver manager, UI time processing, main interface generation, global data factory, component factory, software settings, command line processor, signal processor, event processor and Python registration interface.

2. A method for designing a general application base for CAE software according to claim 1, characterized in that: Registration is used to create and register data creators and event handlers; Initialization is used to perform initialization operations on registered objects and create various global data objects; The event loop is used to process complex business process events based on user interactions; Memory release is used to recycle and release memory after the process ends.

3. A method for designing a general application base for CAE software according to claim 1, characterized in that: The application architecture is used to provide a registration interface for factories and event handling; Global data is used to manage global data; Component management is used to manage generated components and provide access interfaces; The signal adapter is used to implement signal forwarding between components, including console information and thread running progress; The program driver manager is used to start and terminate third-party applications to achieve process-level integration; UI time processing is used to implement global event response; The main interface generation is used to generate the main interface and load qss and translation files at the same time; The global data factory is used to generate global data and put it into global data for management; The component factory is used to create components and put them into the component manager; Software settings are used to set when the software is running, and can read and write INI files; The command line processor is used to process command line parameters; The signal processor is used to perform personalized signal processing; The event processor is used to perform personalized event processing; The Python registration interface is used to implement Python calls.

4. A method for designing a general application base for CAE software according to claim 3, characterized in that: Defines the application architecture based on QApplication.

5. The method for designing a general application base for CAE software according to claim 3, characterized in that: Global data includes geometric data, mesh data, physical model data and post-processing data.

6. A method for designing a general application base for CAE software according to claim 3, characterized in that: Global event responses include keyboard and mouse events and registrable event handlers.

7. A method for designing a general application base for CAE software according to claim 1, characterized in that: Universal application base for integration of multiple CAE software and their subsystems.

8. A general application base design system for CAE software, characterized in that: The system comprises a storage device for executing the steps of claim 1.

9. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores a computer program, which, when executed by a processor, executes a method for designing a general application base for CAE software as described in any one of claims 1 to 7.

10. A computer device, characterized in that: The device includes a memory and a processor, wherein a computer program is stored in the memory. When the processor runs the computer program stored in the memory, the processor executes a general application base design method for CAE software as described in any one of claims 1 to 7.

Images