HK1215089B - System and method for creating reusable geometry sequences for multiphysics modeling - Google Patents

Description

System and method for creating reusable geometric sequences for multi-physics modeling

Cross reference to related patent applications

The present application claims priority and benefit from international patent application PCT/US2013/054436 filed on 8/9 in 2013, U.S. patent application No.13/835,091 filed on 3/15 in 2013, and U.S. provisional patent application No.61/740,149 filed on 12/20 in 2012, the disclosures of which are incorporated herein by reference in their entirety.

Technical Field

The present invention relates to systems and methods for modeling and simulation, and more particularly, to creating an application interface for forming and solving problems in a modeling system.

Background

Computer design systems are used primarily for the development of product designs and may include a graphical user interface. The computer design system may incorporate a software package for analyzing a design of an aspect, such as a structural analysis in combination with a computer aided design system. What is needed by users is a design system that can operate in a more customized environment suitable for a particular use.

Disclosure of Invention

One aspect of the invention is a system adapted to model a physical system by generating a customized application data structure. The system includes one or more processors, one or more user input devices, an optional display device, and one or more memory devices. In use, the one or more processors are adapted to embed a data structure of a predetermined or selected multiphysics model into an application data structure. The multi-physics model data structure includes representations of one or more physical system models, each representing a physical phenomenon and/or physical process. Included in the multi-physics model data structure is data representing at least one modeling operation used to decide how to model or simulate one or more physical system models. Geometric data representing one or more geometric subroutines is added to the embedded multi-physics model data structure. The added geometric data includes parameter definitions for the one or more physical system models. Call data representing one or more geometric subroutine calls used to execute at least one of the one or more geometric subroutines is added to the embedded multiphysics model data structure. Application data representing one or more application features, each including one or more primary data representing at least one form feature and/or secondary data representing at least one action feature, is added to the application data structure. The form features include data specifying input data and/or output data, and/or a representation format of the input and/or output data; the action features include data that specifies a sequence of operations to be performed when executing the application data structure. In the sequence of operations to be performed, at least one operation comprises at least one modeling operation. In a sequence of operations to be performed, at least one of the operations comprises an operation of providing data for generating at least one geometry of at least one part of one or more models of physical systems. A custom application data structure is thus generated that, when executed, provides customized modeling of the physical system as follows: the modeling uses at least one modeling operation, at least one geometry of at least a portion of the one or more physical system models, at least one application feature of the one or more application features (e.g., including at least one form feature), and at least one geometry subroutine of the one or more geometry subroutines.

Another aspect of the invention is a method of generating a customized application data structure to model a physical system. The method includes embedding a data structure of a predetermined or selected multiphysics model into an application data structure. The multi-physical field model data structure includes a representation of one or more physical system models, each representing a physical phenomenon and/or physical process. Included in the multi-physical field model data structure is data representing at least one modeling operation used to decide how to model or simulate one or more physical field system models. Geometric data representing one or more geometric subroutines is added to the embedded multi-physics model data structure. The added geometric data includes parameter definitions for the one or more physical system models. Call data representing one or more geometric subroutine calls used to implement at least one of the one or more geometric subroutines is added to the embedded multi-physics model data structure. Data representing one or more application features, each including one or more primary data representing at least one form feature, and/or secondary data representing at least one action feature, is added to the application data structure. The form features include data specifying input data and/or output data, and/or input and/or output data representation formats; the action features include data that specifies a sequence of operations to be performed when executing the application data structure. At least one operation of the sequence of operations to be performed includes at least one modeling operation. At least one operation of the sequence of operations to be performed includes an operation of providing data to generate at least one geometry of at least one portion of one or more models of physical systems. Custom application data structures are generated through inline and add operations. When this data structure is executed, customized modeling of the physical system is achieved by using at least one modeling operation, at least one geometry of at least a portion of the one or more physical system models, and at least one of the one or more application features (e.g., including at least one form feature), as noted herein.

Yet another aspect of the invention is an apparatus for generating an application data structure that includes a physical computing system containing one or more processing sections, one or more user input devices, a display device, and one or more storage devices. At least one of the one or more storage devices includes executable instructions to generate an application data structure. The executable instructions, when executed, cause at least one of the one or more processing sections to perform operations for embedding a multi-physics model data structure of a physical system into an application data structure. The embedded multi-physics model data structure includes at least one modeling operation of a physical system. One or more geometric subroutines are added to the embedded multiphysics model data structure through at least one of the one or more input devices. At least one of the one or more geometric subroutines includes a parameter definition associated with a physical system. One or more calling features are added to the embedded multi-physics model data structure through at least one of the one or more input devices. The calling feature allows execution of the geometry subroutine. Determining, by at least one of the one or more processing portions, one or more application features to be added to the application data structure. The one or more application features are associated with a physical system model. Adding, by at least one of the one or more input devices, primary data representing at least one form feature for at least one of the one or more application features of the physical system model. Adding, by at least one of the one or more input devices, secondary data representing at least one action characteristic for at least one of the one or more application characteristics of the physical system model. Secondary data representative of the at least one action feature is associated with the at least one modeling operation for the physical system to define a sequence of operations for modeling the physical system.

Yet another aspect of the invention is a method performed in a computer system having one or more physical computing devices configured to generate a modified application data structure to model a physical system. The method comprises the following operations: a multi-physical field model data structure is embedded, via one or more physical computing devices, into an application data structure stored in one or more storage devices. The embedded multi-physics model data structure includes at least one multi-physics modeling operation for the physical system being modeled. One or more geometric subroutines are added to the embedded multiphysics model data structure via one or more input devices. At least one of the one or more geometric subroutines includes a parameter definition associated with a physical system. One or more geometric subroutine calls are added to the embedded multiphysics model data structure through at least one of the one or more input devices. The one or more geometry subroutine calls allow the geometry subroutines to be executed. Determining, by at least one of the one or more physical computing devices, one or more application features to be added to an application data structure. The one or more application features are associated with a physical system. Obtaining, by at least one of the one or more physical computing devices, application data representative of the determined one or more application characteristics. The application data includes form data representing at least one form feature for modeling the physical system and action data representing at least one action feature for modeling the physical system. The motion data representing the at least one motion feature is associated with the at least one modeling operation for the physical system defined in the embedded multi-physics model data structure. The association between the action data and the at least one modeling operation defines a sequence of operations for modeling the physical system.

Another aspect of the invention is a method performed in a computer system that includes one or more processors configured to generate an application model data structure for modeling a physical system. The method comprises the acts of: a plurality of applications for modeling one or more physical systems is determined by one or more processing sections. The plurality of applications are defined by application data stored in one or more application data structures. Displaying a list of the plurality of applications in one or more graphical user interfaces. A first input is received indicating a first selection of at least one of the plurality of applications. In order to select at least one of the plurality of applications, one or more application characteristics are determined by at least one of the one or more processing portions. At least one of the one or more application features comprises the following geometric operations: the geometric operation is represented as application data defined or retrieved in at least one of the one or more application data structures. Displaying the determined application feature in at least one of the one or more graphical user interfaces. A second input is received indicating a second selection of at least one application feature. The second selection includes application features for a geometry operation that calls a geometry subroutine. Determining, by at least one of the one or more processing portions, one or more settings for selecting at least one application feature. The one or more settings are associated with parameters for modeling one or more physical systems. Each edit box including at least one of the one or more settings is displayed through at least one of the one or more graphical user interfaces. At least one edit box is selected. Receiving, by one or more user input devices, an edit of the one or more settings included in the selected at least one edit box.

In still further aspects of the invention, one or more non-transitory computer-readable media are encoded with instructions that, when executed by one or more processors associated with a design system, a simulation system, or a modeling system, cause at least one of the one or more processors to perform the above-described method.

Other aspects of the invention are within the ordinary skill of the art in light of the detailed description of the various embodiments which are illustrated by the accompanying drawings, which are briefly described below.

Drawings

The features and advantages of the present invention may be more clearly understood by referring to the accompanying drawings and the detailed description of exemplary embodiments.

FIG. 1 is an example of a computer system.

FIG. 2 is an example of a system that may reside and execute on one of the hosts shown in FIG. 1.

FIG. 3 is an example of a graphical user interface for selecting a spatial dimension.

FIG. 4 is an example of a graphical user interface for adding one or more physical field interfaces.

Fig. 5 is an example of a graphical user interface for selecting one or more study types.

Fig. 6 is an example of a graphical user interface for setting physical properties in a physical field interface.

FIG. 7 is an example of a graphical user interface for modifying partial differential equation(s).

FIG. 8 is an example of a graphical user interface for performing one or more material property settings for a field in a multi-physics model.

Fig. 9 is an example of a graphical user interface for setting physical boundary conditions in a physical field interface.

FIG. 10 is an example of a graphical user interface for modifying one or more boundary conditions of a partial differential equation.

FIG. 11 is an example of a graphical user interface for a setup window for solving a study step including a system of partial differential equations.

FIG. 12 is an example of a model tree structure including primary and secondary nodes.

13-15 are example flow charts of steps for specifying and solving a system of partial differential equations in a multi-physics modeling system.

FIG. 16 is an example of a flow chart of one method for creating an application data structure, including adding a geometry subroutine.

FIG. 17 is an example Unified Modeling Language (UML) object diagram of an instance hierarchy between features in an application data structure.

FIG. 18 is an example of an application tree structure for adding a multi-physics model to an application data structure.

FIG. 19 is an example of an application tree structure that adds an application feature to an application data structure.

FIG. 20 is an example of a setup window for an application feature.

FIG. 21 is an example of an application tree structure for adding an entry declaration to an application data structure.

FIG. 22 is an example of an application tree structure that adds an input panel form to an application data structure.

Fig. 23 is an example of a setting window of one field panel.

FIG. 24 is an example of an application tree structure for adding a text entry form to an application data structure.

Fig. 25 is an example of a setting window for text input.

FIG. 26 is an example of an application tree structure that adds an activation condition to an application data structure.

FIG. 27 is an example of an application tree structure that adds a panel collection form and a data display output form to an application data structure.

Fig. 28 is an example of a setting window of a data display output form.

FIG. 29 is an example of an application tree structure that adds an action feature to an application data structure.

Fig. 30 is an example of a setting window of an action feature.

FIG. 31 is an example of an application tree structure for adding a menu input form to an application data structure.

FIG. 32 is an example of a graphical user interface for building a blender application data structure in an application developer module.

FIG. 33 is an example of a tree structure of application features for a container application feature.

FIG. 34 is an example tree structure of an application feature for an impeller application feature.

Fig. 35a to 35d are schematic diagrams of geometry and selection operations including exemplary geometry subroutines.

FIG. 36 is an example of an application tree structure for waveguide applications.

Fig. 37a to 37c are examples of a waveguide geometry and a model tree structure created by executing a waveguide application including exemplary geometry subroutines.

Fig. 38 is an example of an application tree structure for a waveguide application.

FIG. 39 is a flowchart illustration of method steps for deducting (e.g., executing) an application data structure.

FIG. 40 is an example of a selection window.

41 a-41 b are examples of an application model tree structure window and selection options generated by executing an exemplary executor (activator) and blender application that includes geometric sequence operations.

FIG. 42 is an example of a Unified Modeling Language (UML) object diagram of an instance hierarchy between features in an application model data structure.

FIG. 43 is a flowchart illustration of method steps for deducting (e.g., executing) an application model data structure.

While the invention is susceptible to various modifications and equivalent forms, specific embodiments have been shown by way of example in the drawings and will be described in detail herein. It should be understood, however, that the invention is not intended to be limited to the particular forms disclosed. On the contrary, the invention is intended to cover all modifications, alternatives, and equivalents as may be included within the spirit and scope of the invention as defined by the appended claims.

Detailed Description

While embodiments of this invention are susceptible of embodiment in various forms, there is shown in the drawings and will herein be described in detail certain preferred embodiments, with the understanding that the present disclosure is to be considered as an exemplification of the principles of the invention and is not intended to limit the broad aspect of the invention to that illustrated in the present disclosure. To facilitate this detailed description in this disclosure, words containing only the singular may include the plural unless expressly stated otherwise, and vice versa; "and" or "are both a conjunctive and a selective; "all" means "any and all"; "any" means "any and all"; "including" means "including but not limited to".

The present invention expands the range of flexibility and capabilities in modeling systems by allowing customized applications to be generated. Adding geometric subroutines to a multi-physics model of an application data structure for modeling a physical system allows applications to become more customized and reusable. For example, the geometric subroutine can be extended to accept objects and selections as input. As another example, the definition of cross-sections of geometric subroutines can be simplified by defining cross-sections of a working plane in a multi-physics modeling system. Further, as illustrated in non-limiting exemplary aspects of the invention, the customization of applications, such as applications of multi-physics models provided by the present invention, allows for the definition of models and the execution of simulations for specific physical systems. The customization of the application further allows the design of the physical system being simulated to become optimized and also enables the determination of design outputs that are used to control the manufacturing process of the physical system.

From these concepts, applications can be tailored for very specific uses. The authors of the present application may be scientists or engineers versed in modeling and simulations and the processes or phenomena depicted by these simulations. Modeling and simulation are generally used to understand, predict, optimize and control some device, process or phenomenon.

The authors of the present application may be signed up by an application user (future user) for the purpose of developing an application that describes a particular device, process or phenomenon. These engineers (typically) do not define models and do not use physical field interfaces in multi-physics modeling software to run simulations. Application users will then use the present application to understand, predict, optimize, and control processes or phenomena under different conditions and uses. In one case, an application user uses an application to define a model, run a simulation to optimize the design of a device (or process) simulated by the model, create a drawing based on this optimization, and build a device from the optimized design. In one embodiment, manufacturing equipment with computer control is combined with aspects of the present concepts disclosed herein, and a piece of equipment can be optimized on one computer, which then sends the resulting output to another computer that controls one or more manufacturing equipment or machines. If the purpose of the model is to control a process, then the automatic control design can be obtained directly from the application model.

The optimization facilitated by the present concepts can facilitate the design and/or control of a device or process by an engineer who is not a modeling expert.

This document describes examples of methods and systems for creating and forming application data structures. It is contemplated that the method may be performed as part of an application interface developer module that may be a stand-alone system that interfaces or interfaces with an engineering analysis system, such as a multi-physics modeling system. It is also contemplated that the application program interface developer module may be one of a plurality of modules or routines including an engineering analysis system. The application interface developer module may include or interface with a user interface, such as a graphical user interface, for receiving user input from the application interface developer and displaying instructions thereto. The application interface developer module is used to create application data structures and can be executed on one or more processors associated with the various computer systems described elsewhere in this disclosure, including the computer systems and devices described in this disclosure for the multiphysics modeling system.

It is contemplated that an application program interface should be available to or accessible through an engineering analysis system, such as a multi-physics modeling system, to generate the models (e.g., model data structures including data frames, methods, and their interactions) described in the model objects according to an object-oriented programming language (e.g., C + +, C #, Java @).

In some aspects, an application interface for creating or forming an application data structure can be represented as a branch including multi-physics model setup nodes, such as aspects of a multi-physics modeling system described elsewhere in this document by model tree structure features. Branches and nodes may be included in a graphical user interface, and the described settings may include domain settings, boundary conditions, and initial conditions, among others.

It is further contemplated that the application interface developer may also allow a user to name the application interface. For example, the name of an application interface may be descriptive information of the application it defines and may be displayed in a user interface (such as a model tree structure) of an engineering analysis system, such as a system that performs multi-physics simulations. The system user can do the renaming operation, or when one multi-physics model can add or use a plurality of same-type application program interfaces, the system can do the renaming operation by itself.

Computer aided engineering systems such as finite element analysis systems, finite volume systems, and finite difference systems are typically provided with a graphical user interface for a user to set up or run a simulation. Such a process or system may include several user interfaces to perform different types of simulations, such as CFD, heat transfer, electromagnetic, or structural mechanical simulations.

Methods for building and solving multi-physics problems, as well as other modeling systems described in this document, such as fig. 3-15, are also described in U.S. patent No. 8,219,373 issued on 7/10/2012, U.S. patent No. 7,623,991 issued on 11/24/2009, 7,519,518 issued on 4/14/2009, U.S. patent No. 7,596,474 issued on 9/29/2009, U.S. patent application publication No. 2012/0179426 issued on 12/2012/7/15/2011, which are incorporated herein by reference in their entirety. These published patent documents describe, for example, a method of setting and executing a multi-physical field simulation including a plurality of coupled physical phenomena by receiving an input of a physical property form expressed in physical quantities. Further, methods of setting problems using physical properties, physical quantities, and physical phenomena described by partial differential equations (sets) are disclosed in the above-cited U.S. patents and patent application documents. These published patent documents provide methods and systems for setting up and solving multi-physics problems using predefined application patterns, which are referred to as physics field interfaces in this disclosure. The physical field interface components may include parameters, variables, physical attributes, physical quantities, boundaries and initial conditions, and solvers with settings and menus. These settings and menus can be customized for a particular physical field, rather than using a common mathematical setting. Furthermore, for the case where a predefined physical field interface cannot be used, a partial differential equation model method (also called partial differential equation interface) is also described in these published patent documents. Using a common partial differential equation model and a partial differential equation interface to set up a multi-physical field problem requires knowledge of the aspects of describing physical properties, physical quantities and physical phenomena with partial differential equations.

It is contemplated that when generating application data structures based on a multi-physics model, operating or adaptation system and method, it may be desirable to provide various computational advantages for engineering systems, including modeling and simulation systems, simultaneously. The application developer module is configured or adapted to access features and feature settings in the multiphysics model, and to run the method and system for generating application data structures in its dedicated graphical user interface. Existing settings that utilize the multi-physics model may also be accessed through this graphical user interface to generate data structures that represent the application. The application data structure may be further deduced (e.g., executed) by another system or method that enables the application data structure to be accessed through a graphical user interface in a multi-physics modeling system to generate an application model data structure and a multi-physics model data structure to allow execution of the simulation.

The entire disclosure describes various non-limiting exemplary aspects of the system, including methods that may be executed on a processor unit, accessible through a graphical user interface. These methods include instructions regarding generating application data structures, application model data structures, and other types of data structures for modeling physical systems. It is contemplated that the generated data structure may be used or may be associated with an engineering analysis system (e.g., a multi-physics modeling system) in which a system user may build and apply the data structure.

In an exemplary aspect of the multi-physics modeling system, input of a physical properties form in physical quantities may be received by a first interpretation module and a model object (e.g., a model data structure) is then generated. The model object may include algorithms and data structures for the model and may be further used to represent the model. The model object may further include methods for setting up and executing sequences of operations to create the geometry, mesh, and solution of the model.

Physical computing devices used to embody an engineering analysis system may configure one or more graphical user interfaces that allow a system user to enter, execute simulations, and build application data structures. The computer system may include some of the non-limiting exemplary routines or methods described above, and may further include different interfaces for different types of simulations. Different user interfaces may be used to perform simulations such as fluid flow, heat transfer, electromagnetic, and/or structural mechanics. Simulation and other engineering or physical phenomenon associated interfaces are also contemplated as being useful in computer aided engineering analysis systems.

The present disclosure contemplates a system that includes a dedicated graphical user interface for generating or building an application data structure and an application model data structure. For example, the computer system may include a graphical user interface to define parameters, forms, features, actions, variables, physical attributes, physical quantities, and/or physical field interface characteristics of physical phenomena associated with the analysis and simulation. The graphical user interface allows a user to access routines or methods and then generate application data structures. The generated data structure may then be interpreted or executed by one of the routines or methods as follows: the routine or method is configured to create an application model data structure and enable access to the application interface from other graphical user interfaces associated with, for example, an engineering analysis system, such as a multi-physics modeling system. It is contemplated that the routines or methods of these operations may be executed locally and/or remotely over a network to one or more processing units executing an engineering analysis system.

The computer system may be used to perform a variety of different tasks described in this disclosure. In one aspect, a computer system may be used to execute one or more computer programs, including an engineering analysis system and method, stored in a computer-readable medium (e.g., temporary or fixed memory, magnetic storage, optical storage, electronic storage, flash memory, other storage media). A computer program may comprise instructions which, when executed by a processor, perform one or more tasks. In some embodiments, a computer system executes machine instructions, which may be generated during processes such as translation of source code into machine-executable code, to perform modeling and simulation, and/or problem-solving tasks. In one technique that may be used to model and simulate a physical phenomenon or physical process, various physical attributes and quantities within the physical phenomenon or physical process being modeled and simulated are represented using variables and equations (sets) or other quantifiable forms that may be processed by a computer system. These systems of equations or other quantifiable forms, in turn, may be solved by a computer system, which is typically configured to solve one or more equation-associated variables, or to solve a problem via other input parameters received.

It is envisaged that the use of a computer program to model and simulate a physical phenomenon or process may provide a number of advantages, particularly where the complexity of the physical phenomenon or process being modeled and simulated for analysis increases. For example, in some embodiments, a user can incorporate one or more physical phenomena into a multi-physics model, such as part of an engineering analysis. To further illustrate this example, a user may combine the phenomena described by chemical dynamics and hydrodynamics, electromagnetic phenomena and heat transfer, structural mechanics and fluid flow, or other physical phenomena. Such multi-physics models may also involve multiple physical processes. For example, one process may include a driver driven by an amplifier, where both the amplifier and the driver are part of a multiphysics model. The multi-physics modeling may also include solving the coupled system for partial differential equation(s).

It is contemplated that a networked computer or processor may be included in a computer system on which a modeling system operates, such as the modeling systems described in this disclosure. In some embodiments, the processor may run directly on the modeling system user's computer; in other examples, the processor may be running remotely. For example, a user may enter various parameters on a computer or terminal located at a certain location. The parameters may be processed locally on the computer or transmitted over a local or wide area network to another processor located elsewhere in the network and configured to process the input parameters. The second processor may be associated with a server connected to the internet (or other network); or a plurality of processors connected to the internet (or other network), each of which will be responsible for performing a specified function in developing and solving a problem for a modeling system. It is further contemplated that the results of one or more processor processes may be assembled on another server or processor. It is also contemplated that the results may be returned to the terminal or computer where the user is located for assembly. The terminal or computer on which the user is located may then display the solution for the multi-physics modeling system to the user in the form of a display screen (e.g., a transient display) or a hardcopy record (e.g., via a printer). Further, the solution may be stored in a memory associated with the terminal or computer, or in a server accessible to another user and obtaining the solution for the modeling system.

It is contemplated that a product or process in certain embodiments may be in a feasibility stage of development or design/analysis. For a product or process that is in a development or analysis stage, it may be desirable to evaluate its application in a complex environment that contains multiple physical attributes and quantities. In computer-based design systems, it is desirable to solve complex multi-physics problems by systematically altering parameters and geometric features. Other desirable features may include, for example, the ability to have a computer-based system for solving complex multi-physical field problems, wherein the physical properties and boundary condition settings used to form the multi-physical field model and/or solve the multi-physical field problem are stored in a memory and directly accessible through the design system.

Referring now to FIG. 1, there is illustrated an example computer system that may be used with the methods described elsewhere in this document, including modeling systems and systems for generating application data structures. Computer system 110 includes a data storage system 112 coupled to host systems 114 a-114 n via a communications medium 118. In this embodiment of computer system 110, "n" hosts from 114 a-114 n may access data storage system 112 to perform input/output (I/O) operations. Communication medium 118 may be any network or any other type of communication connection known in the modeling and computer simulation arts. For example, communication medium 118 may be the Internet, an intranet, or other network type that provides communication between host systems 114 a-114 n and data storage system 112, as well as with other portions of computer system 110, including, but not limited to, systems based on various forms of network communication (e.g., fiber optic, wireless, Ethernet).

Each of the host systems 114 a-114 n, as well as the data storage system 112 included in the computer system 110, may be connected to the communication medium 118 using each of the connection types provided and supported by the communication medium 118. The processors included in the host computer systems 114 a-114 n or data manager system may be various commercially available single-processor or multi-processor systems, such as Intel-based processors, IBM mainframes, servers, or other commercially available processor types capable of supporting the input communication of specific embodiments and applications.

Note that the details of the hardware and systems included in each of the host systems 114 a-114 n and the data storage system 112 are described in detail in this disclosure, but may vary from one embodiment to another. Each of the host computers 114 a-114 n and the data storage system 112 may be located at the same physical location or may be located at different locations. For examples of communication media that provide different types of connections between host computer systems, data manager systems, and data storage systems in computer system 110, different communication protocols may be used, such as SCSI, ESCON, fibre channel, or peer-to-peer protocols as known to those skilled in the art of computer modeling and simulation. Some or all of the connections between the hosts and the data storage system 112 and the communications medium 118 may be through other communications equipment, such as Connectrix or other physical or virtual switch equipment that may exist, such as telephone lines, repeaters, multiplexers, and even satellites.

Each host computer system may perform different types of data operations, such as storing or retrieving data files associated with applications executing in one or more host computer systems. For example, a computer program may be executed on host computer 114a to store and retrieve data in data storage system 112. Any number of various data storage devices, such as disks, tapes, etc., may be included in data storage system 112, depending on each particular implementation. As described in the following paragraphs, the method may reside and be run on any of the host computer systems 114 a-114 n. The data may be stored locally at the host system performing the method, or remotely at data storage system 112 or another host computer system. Also, based on the configuration of each computer system 110, the methods described herein may be stored and executed on one of the host computer systems, and a user may remotely access data local to the other computer system. The computer system 110 of FIG. 1 is described in connection with specific embodiments, various system configurations and variations may occur in actual engineering and should not be construed as limiting the technology described elsewhere in this document.

Referring now to FIG. 2, an example of a modeling system 219 is illustrated that may reside on a single computer or one of a plurality of host computer systems (e.g., host computers 114 a-114 n). The modeling system may be divided into several different components. In one example of the system, a GUI module 220, modeling and simulation module 222, and data storage and retrieval module 224 may be included. The GUI module 220 may interact with a system user. The modeling and simulation module 222 may provide functionality for managing and executing multiple physical field simulations. The data storage and retrieval module 224 may load and store the model as a file, may load and store other file types that may be used in a simulation or may be input or output to a simulation.

The GUI module 220 may communicate with the modeling and simulation module 222 by sending and receiving commands. The sending and receiving actions of the commands may be performed by an application programming interface ("API") or similar component. In one aspect, the API may be object-oriented, fusing data and function calls in the same structure. On the other hand, the API may employ a data structure that is independent of the function call.

It is contemplated that, in some aspects of the invention, components in a multi-physics modeling system may reside in different host computer systems. For example, the GUI module 220 may reside on a personal computer host, while the modeling and simulation module 222 may reside on a server computer host. It is further contemplated that data storage and retrieval module 224 may reside in the personal computer host, the server computer host, or another separate computer host. If the computer hosts are different, the API may be configured to communicate between the hosts over a computer network. The object-oriented API may be configured to send data and method calls in a computer network in one embodiment, or configured to send data and function calls among components of a computer network in another embodiment. The API may also be used to handle a data storage and retrieval module 224, which may be hosted by the GUI module 220, hosted by the modeling and simulation module 222, or a separate host. In each of the above cases, the data storage and retrieval module 224 may be configured to load and store files on each of these hosts.

It is contemplated that in some aspects, the system 219 may include or be configured with an operating system, such as Windows 8, Mac OS, iOS, android, Chrome OS, or the like, or include other system components not depicted or characterized in the emulation system 219 (shown in FIG. 2). In the example of FIG. 2, the library 226 and user data file 228 may be stored locally at the host computer system. It is further contemplated that, in some aspects, the library 226 and/or user data files 228, as well as copies of such files, may be stored in another host computer system and/or data storage system 112 in computer system 110. However, for simplicity and to facilitate the description in the following paragraphs, it may be assumed in a non-limiting manner that system 219 resides on a separate host computer system like 114a and maintains additional backups, such as user data files and libraries, in like data storage system 112.

In some aspects of the invention, like GUI module 220, modeling and simulation module 222, data storage and retrieval module 224, and/or library 226 these components of modeling system 219 may be included in a commercial system software package, or may be implemented in conjunction with the latter. These components may run on any of the host systems 114 a-114 n, and may include one or more operating systems, such as WindowsWindows 7、Windows 8、Windows HPC Server 2008R2、MaciOS，ChromeAnd so on. It is further contemplated that the modules in modeling system 219 may be written in a variety of computer programming languages, such as, for example, C, C + +, C #, and,Or any combination thereof, or other commercially available programming languages.

It is contemplated that the GUI module 220 may display a GUI and be used to acquire data required by a system user in analyzing modeling, simulation, and/or solution of physical phenomena and processes that may be assembled and solved by the modeling and simulation module 222. That is, the system may collect or receive user data through these modules, such as GUI module 220, and then for use by modeling and simulation module 222. The data may then be transmitted or forwarded to a data storage and retrieval module 224, where the user input data may be stored in a separate data structure (e.g., user data file 228). It is contemplated that other data and information may also be stored and retrieved in a separate data structure, such as library 226, and used by modeling and simulation module 222, or in conjunction with GUI module 220.

The various data files associated with the modeling system, such as user data files 228 and library 226, may be stored in any of the data file formats of the host computer system or file system of data storage system 112. In certain aspects, the system 219 may use either database software package in the storage and retrieval of data. User data file 228 may also be used with other simulation and modeling systems. For example, user data file 228 may be stored in a format that may be used directly or indirectly as an input to any other modeling system. In some aspects, data may be imported and/or exported between the multi-physics modeling system and another system. The data format may be altered or customized depending on each system and the additional functionality included with each system.

It is contemplated that the systems and methods described in this disclosure document may be used in conjunction with physical field interfaces that model for different physical phenomena or processes. The combination of multiple physical field interfaces may be referred to as a multi-physical field model. The properties of the physical field interface may be expressed in terms of partial differential equations that may be automatically combined in the present system and method to form a coupled partial differential equation set or other form. The coupled system of partial differential equations may be presented in the form of an "equation view" and allow modification and use as inputs to the solver. It is also contemplated that when a system of partial differential equations is submitted to a solver, it may be implemented as a separate system of partial differential equations or partial differential equations describing a single phenomenon or process, or one or more systems of partial differential equations describing multiple phenomena or processes.

In some aspects of the invention, a multi-physics modeling system may provide functionality for coupling physics field interfaces for physical property modeling by one or more graphical user interfaces that allow a user to select one or more physics field interfaces from a list. It is further envisaged that a graphical user interface may select the variable name of the physical quantity from the names of the physical field interfaces. It is envisaged that the formula of the physical field interface may differ depending on the set characteristics of the "study", which will be described in more detail elsewhere in this document.

It is further contemplated that a multi-physics modeling system may be required to access predefined combinations of physical phenomena for defining a multi-physics model. The predefined combination may be referred to as a multi-physics interface, which, like the physics interface, may also have different formulas depending on the set characteristics of the study.

It is contemplated that in some aspects of the invention, the physical properties may be used to model physical quantities of one or more components and/or processes being investigated by the modeling system, which may be defined by a graphical user interface that allows the physical quantities to be numerically described. In some aspects, a physical property may also be defined as a mathematical expression that includes one or more numerical values, spatial coordinates, temporal coordinates, and/or actual physical quantities. In some aspects, in one geometric domain, physical properties may be applicable to some portions thereof and not defined in other portions of the geometric domain. The geometric domain or "domain" may be divided into disjoint sub-domains, the mathematical collection of which constitutes the geometric domain or "domain". The complete boundary of a domain may be divided into different parts, i.e. "boundaries". Adjacent subfields may have the same boundary, also referred to as a "boundary". A full boundary is a mathematical collection of all boundaries, including, for example, subdomain boundaries. For example, in some aspects, a geometric subdomain in a graphical user interface may be one-dimensional, two-dimensional, or three-dimensional. However, as detailed elsewhere in this document, a solver may be used to solve for any spatial dimension. It is contemplated that in one operation, a graphical user interface may be used to specify physical properties of a boundary in a domain and used to derive boundary conditions for the partial differential equation(s).

Additional features of the modeling system, such as those in the modeling and simulation module 222, may automatically derive a partial differential equation(s) and boundary condition system for a multi-physics model. The technology comprises the steps of fusing partial differential equation sets of a plurality of phenomena or processes, coupling the processes in different coordinate systems through coupling variables or operators to generate a single coupling partial differential equation set, and performing symbolic differentiation on all dependent variables of a partial differential equation set system to be applied to a subsequent solver solution.

It is contemplated that in certain aspects, the system of coupled partial differential equations may be modified prior to performing the differentiation and sending to the solver. The modification operation may be performed through a setup window of the coupled partial differential equation set displayed in the "equation view" of the graphical user interface. When the system of partial differential equations is modified in this manner, the set portion of the corresponding physical property may become "locked" in state. Subsequent users may unlock these physical attributes through certain operations.

It is contemplated that certain aspects of the present invention may include features for modeling one or more engineering and scientific disciplines, such as acoustics, chemical reactions, diffusion, electromagnetism, hydrodynamics, geophysical, heat transfer, optics, plasmonic physics, quantum mechanics, semiconductor physics, mechanics, structural mechanics, wave propagation, and the like. Certain aspects of the modeling system may relate to multiple disciplines as mentioned above, and may also include characterization or modeling of combinations of the above disciplines. Further, the techniques described herein may be used for one or more partial differential equation set systems.

It is contemplated that, in certain aspects of the present disclosure, one or more partial differential equation system may be represented by a generalized type, a coefficient type, and/or a weak solution type. The coefficient type is more suitable for linear or approximately linear problems, and the generalized type and the weak solution type are more suitable for nonlinear problems. One or more systems being modeled may include one or more related studies, such as steady state, transient, eigenvalue, or eigenfrequency. In aspects described in this disclosure document, a Finite Element Method (FEM) may be combined with methods such as adaptive mesh partitioning, adaptive time stepping, and/or selection of one or more different numerical solver classes to solve a system of partial differential equations.

It is contemplated that in some aspects of the invention, the finite element mesh may include a simplex for characterizing a geometric domain. Each simplex may belong to a separate subdomain and the collection of simplices may form an approximate geometric domain. Geometric dimensions one-dimensional, two-dimensional, and three-dimensional domain boundaries can also be represented by zero-dimensional, one-dimensional, and two-dimensional simplifications, respectively.

It is further contemplated that a mesh representing a geometry may also be created by other software or external applications, and then may be imported and used to create one or more of the modeling systems described in this disclosure document.

The initial value of the solving process may be a numerical value, or may be an expression including a numerical value, a spatial coordinate, a temporal coordinate, and an actual physical quantity. The initial values may also comprise physical quantities determined in a previous investigation step.

The solution of the partial differential equation(s) may be determined from a subset of the physical properties and their associated physical quantities. Furthermore, the unsolved subset may be used as an initial value for the system of partial differential equations.

It is contemplated that the user may best make a selection of spatial dimensions, physical field combinations, and study types in a multi-physics modeling system through a model wizard. The model wizard may take the user to complete these selection steps and may allow combining multiple spatial dimensions, multiple physical fields, and multiple research or research steps in one multi-physical field model.

Referring now to FIG. 3, an example of a user interface or GUI330 for specifying spatial dimensions 332 of a multi-physics model is shown. The model may be specified in a coordinate system with spatial dimensions of zero-dimension (space independent, time-domain only), one-dimensional axisymmetric, two-dimensional axisymmetric, and three-dimensional. It is further contemplated that a user may incorporate multiple models comprising multiple coordinate system systems as mentioned above to describe a phenomenon or process comprising multiple components or dimensions.

Referring now to FIG. 4, there is shown an example of a user interface or GUI439 for specifying a multi-physics model incorporating a plurality of phenomena or processes (e.g., acoustics, fluid flow, electromagnetism, heat transfer, and structural mechanics). It is contemplated that each phenomenon or process incorporated may correspond to a physical field interface. Through the GUI439, a physical field interface for use in the multiple physical field composite model can be specified. Each physical field interface may be configured to model a physical quantity in the form of a system of partial differential equations. These physical quantities may be directly expressed as dependent variables in partial differential equations or expressed by the relationship between the dependent variables and variables representing the physical quantities. In this example, the system of partial differential equations may be typically in a "hidden" state (e.g., not directly visible) to the GUI user. As previously described, when multiple physical field interfaces are combined into a model or model system, the model or model system may be referred to as a multi-physical field model.

An exemplary list 440 of corresponding physical field interfaces (e.g., AC/DC, acoustic, chemical delivery, electrochemical, fluid flow, heat transfer, plasma, radio frequency, structural mechanics) is also included in the GUI439 for the user to select from, depending on the spatial dimensions selected by the user. To add physical field interfaces to the multi-physical field model, the user may select physical field interfaces in the list and may specify that these physical field interfaces are to be included in a multi-physical field model. For example, the user may right click and then select "Add selected" 442 from the context menu options, thereby adding one physical field interface (such as fluid heat transfer) to the multi-physical field model. Upon completion of the selection, the physical field interface will be added to the "selected physical field" list 444 below the physical field list in GUI 439. The physical field interface may be removed from the list by a "delete selected" button 446.

Each physical field interface in the multi-physical field model is named a unique name for determining the source of the variable in the multi-physical field model. Adding the physical field interface to the "selected physical field" list 444, the user can edit the name of the dependent variable representing the physical quantity being solved for. For example, a user's editing operation may assign a new name to a variable, such as "temperature" in "dependent variable" column 448 in GUI 439.

It is contemplated that the optional interface may also include a mathematical interface 443 that directly corresponds to the system of partial differential equations. In one or more mathematical interfaces, the physical quantities may be represented by dependent variables in a multi-physics model. It is contemplated that in some aspects, more than one dependent variable may be included in each mathematical interface. It is further contemplated that the number of dependent variables and the dimensions of the system of partial differential equations can be entered in the "dependent variables" field 448 in the GUI 439.

Referring now to FIG. 5, an example of a user interface portal or GUI 549 for specifying one or more study types for a multi-physics model is shown. In some aspects of the modeling system, the interface may include a preset study associated with the selected physical field interface. Customized study steps may be supported on the interface, for example, a study that customizes each physical field interface, or partly a pre-set study (e.g., steady state, transient state), partly a customized study (e.g., characteristic frequency). It is further contemplated that the study may include a plurality of study steps associated with a simulation study of the multi-physics model.

It is contemplated that in certain aspects of the invention, the type of analysis to be performed in the multi-physics model, such as steady state, transient, eigenvalue, and eigenfrequency, may be determined by research. The study may control the type of equations used in the multi-physical field model, the type of grid (e.g., selected from a list of possible grids), and/or the type of solver that may be used to solve different studies or study steps in the multi-physical field model. In one example, the study may include a steady state study step followed by a transient study step. The study will then prepare equations, grids and solvers for steady-state and transient study steps. The user may select a study in the study list 550 and then click the "done" button 554 to end the model wizard step.

It is contemplated that in certain aspects of the present invention, the multi-physical model data (e.g., selections made in GUIs 330, 439 and 549) may be communicated from the GUI (e.g., 220) to a data storage and retrieval module (e.g., 224) for storage in a user data file (e.g., 228). For example, a multi-physics model created according to the model wizard steps described in fig. 3-5, including geometry, materials, physics field interfaces, grids, studies, and results, may be presented in the GUI as a model tree structure. By selecting (e.g., left-clicking) a node in the model tree structure, the user is given access to the set options for the operation represented by the node. Further selection of a node (e.g., right clicking) may also enable the user to access a menu from which to perform actions such as adding attributes or operations to the corresponding node. These added attributes and operations may be represented as child nodes of the selected node.

It is contemplated that in some aspects of the invention, one or more of the screen displays (e.g., GUI330) as previously described may be displayed through a portion of a GUI module (e.g., 220) component of a modeling system (e.g., 219). It is further contemplated that the modeling system may be configured to incorporate a variety of different physical field interface types, including some predefined interfaces and/or user-defined interfaces. The predefined physical field interface may be an interface whose interface attributes are contained in a library (e.g., 226), which may be obtained from a supplier (e.g., the supplier may provide a library containing predefined partial differential equation set systems, analysis types, GUIs, and the like in a particular system, such as heat transfer). The user-defined physical field interface is configured to be able to support a user-defined model or physical field interface for which a user may specify a system of partial differential equations, quantities being simulated, and the like. The user-defined models may be stored in a user-defined library, such as a library contained in a user data file (e.g., 228). Definitions and other data files associated with the user-defined model may be stored in any of a number of data formats, such as similar to those in a library (e.g., 226). It is contemplated that the format and operation of the stored models and model parameters may vary.

Referring now to fig. 6, there is shown an example of a setup window 659 for physical property setup in an exemplary physical field interface, such as solid heat transfer. It is contemplated that each physical field interface may have one or more GUI setup windows customized according to the described physical phenomena or processes, in which a user may set physical properties associated with the physical field interface. The physical field interfaces and their settings can be represented as nodes in a model tree structure. For example, selecting (e.g., right clicking) a physical farm interface node opens a form in which the user may perform one or more tasks, such as adding domain attributes or settings to the physical farm interface, renaming nodes, or displaying attributes of the selected node.

The settings window 659 contains a domain list 660 that may include one or more geometric domains to which the physical attributes apply. A domain may also be referred to as a subdomain. It is contemplated that in the graphical window, the user may select one or more of the sub-domains by directly selecting (e.g., via a mouse, keyboard, or other selection feature) a graphical representation in the geometric domain. It is also contemplated that, in some cases, a user may select multiple domains based on a predefined selection of domains that represents a particular portion of a component in the multi-physics model being modeled.

The physical properties of the domain (or subdomain) may be specified in a settings window. As previously described, the physical properties may be represented in different forms, including numerical values 662, symbolic representations 664 of one or more spatial coordinates, physical quantities, and derivatives thereof in space and/or time. It is also contemplated that the physical quantities may also be defined from material 666, and in this case, may be defined elsewhere in the model as described elsewhere in this disclosure document. It is further contemplated that the physical quantities may be specified by a program or routine for calculating values of physical properties. The name of the program or routine, and any parameters that may be included, may be entered in settings window 659. In one example, may pass through C, VisualFortran、Or Microsoft WindowsA program or routine is written. According to specific implementation requirements, and thereinThe calling standards and conventions involved, and the programming languages used for implementation may vary.

Reference is now made to FIG. 7, which is an example of a GUI 769 that can modify the system of partial differential equations through an "equation view" window. For example, a system of partial differential equations, such as example equation 772, may be defined through the physical field interface and presented to a user, here subject to user modification, to introduce one or more descriptions that are not defined in the corresponding property settings window. For example, when the user selects the "display equation view" element from the menu, the system of partial differential equations is displayed. It is contemplated that in some aspects, each attribute in the model will then display a corresponding "equation view" and corresponding settings window 770 where the equation may be modified by the user. The "equation view" may be represented as a child node (e.g., unit 774) of a physical field interface attribute node (e.g., unit 776). It is contemplated that in some aspects, when a change is made in the settings window 770 of an "equation view" node (e.g., element 774), the corresponding physical field interface property settings may be locked. In one aspect, a lock marker may be placed on the physical field interface icon (e.g., element 776) to indicate that one or more properties of the interface in the model tree are locked. Likewise, these attributes may be unlocked by the user, for example, by selecting the "all resets" feature 778 or other element in the corresponding settings window corresponding to the "equation view" node 774.

Referring now to FIG. 8, therein is shown an example of a material settings window 879 for a domain material property. The material settings may include material properties of some or all of the physical field interfaces in a multi-physical field model. It is contemplated that different materials selected may be included in the model for different domains identified in domain selection list 880. The material properties may be defined by a user or may be obtained from a predefined material library. In the material setup window, the list of material properties catalog 882 may display the material property usage status of the selected material on the selected domain, taking into account the physical field interface in the multi-physical field model. For example, in the joule heating process example, the catalog listing of material properties may be marked by icons with properties related to the joule heating multi-physical field process, as well as properties described in the multi-physical field interface. Such material properties may include, for example, heat capacity, thermal conductivity, electrical conductivity, relative dielectric constant, and density. The user may define material properties for describing joule heating through the material setting window 879. Any desired material properties may be marked or identified by an icon 884 or other indicia (e.g., a check mark). If the desired material property is not defined, the list of material properties catalog 882 will indicate this material property in a manner that highlights it (e.g., using a red stop symbol icon).

It is contemplated that the user-defined materials and material properties may be stored in a user-defined materials library, which may be subsequently accessed, used for separate or different models. A user can create a material library for specific application, and the flexibility of material definition is expanded; additionally, system developers are also supported in creating material libraries that can be used with the multi-physics modeling system.

It is contemplated that the materials and material properties in the modeling system can be represented as nodes in a model tree structure, and that a user can display, rename, and/or add the materials and material properties in nodes in tabular form (e.g., by right clicking, or otherwise selecting corresponding nodes in the model tree structure).

Referring now to fig. 9, therein is shown an example 989 of a boundary condition setting window for a physical property (e.g., temperature) of a physical field interface (e.g., a heat transfer interface). The settings window 989 may include a boundary list 990 to specify the geometric boundaries to which the one or more physical properties apply. It is contemplated that in one or more graphical windows, a user may add one or more boundaries to the list of boundaries by selecting a graphical representation of the boundary in the geometric domain. The selection of the boundary may be accomplished by selection-like devices commonly used in computer systems (e.g., mouse, keyboard, other selection devices). It is further contemplated that the user may also select a boundary (e.g., a boundary selection) via a predefined boundary selection that represents a particular portion of a boundary of a component in the multi-physics model being modeled, which may include all or a portion of the boundary of the component.

The physical properties of the geometric boundary may be specified through a setup window 989 for the boundary condition to which it corresponds. These attributes may be expressed as numerical values 992, symbolic expressions of spatial coordinates, or time-based expressions. It is also envisaged that these attributes may also be expressed as physical quantities of physical field interfaces and their spatial derivatives added from the systems described elsewhere in this disclosure document. It is further contemplated that programs or routines for deciding attribute values may be specified and/or named in a similar manner as described elsewhere in this disclosure document.

It is contemplated that the boundary condition settings in the modeling system may be represented as nodes in a model tree structure, and that a user may add boundary attributes, rename nodes, or display node attributes in the physical field interface boundary conditions (e.g., by right-clicking or otherwise selecting corresponding nodes in the model tree structure).

Referring now to FIG. 10, therein is shown an example GUI 1009 for modifying the boundary condition partial differential equation via another "equation view" feature 1000. For boundary conditions defined by a physical field interface, user modifications may be displayed and accepted in 1002 in order to introduce descriptions that may not be defined in the setup window of the corresponding physical field interface. In one embodiment, the boundary equations may be displayed by user selection, for example, the "display equation view" option in a preferences menu (not shown in FIG. 10). It is contemplated that when the system of partial differential equation boundary equations is modified by an "equation view" feature (e.g., equation view node 1004), the corresponding setting of the boundary condition may be locked. To indicate the locking status of the boundary condition, the boundary condition node 1006 corresponding to the boundary condition attribute in the model tree structure may include a lock flag. The user may unlock the boundary conditions of the corresponding property by selecting the reset all feature 1008, or other unlock feature, of the settings window.

It is contemplated that in some aspects, the modeling system preferably stores the system of partial differential equations, boundary conditions of selected types of physical field interfaces associated with a coupled system of partial differential equations, in a model object (e.g., a model data structure) that will be described in more detail in fig. 13-15. The reason for this setting of the model objects is that if the system of partial differential equations and boundary conditions are modified via the GUI 769 in fig. 7, the corresponding model objects can be updated accordingly. For example, the modeling and simulation module 222 (see, e.g., FIG. 2) examples can create, initialize, and modify model objects containing data associated with a multi-physical field model (e.g., a multi-physical field model data structure) using the setup windows of the domain and boundary, the physical properties of the domain and boundary, respectively, and the possible modifications specified in the "equation view". It is further contemplated that the coupled system of partial differential equations and associated boundary condition domains may also be updated.

Referring now to FIG. 11, another example of a window set for a study step (e.g., steady state, transient state, frequency domain) 1109 that may be used in connection with solving a study that includes one or more study steps is shown. The set window 1109 may be associated with solving any one or more physical field interfaces, or a system of partial differential equations coupling any subset of physical quantities in a system of partial differential equations. The GUI of the settings window 1109 includes a physical field interface display area 1110 in which one or more selected physical field interfaces of the multiple physical field model are listed. Setting the window 1109 may also support the selection of different grids 1112, different discretizations 1114, and tolerances for different research steps. It is contemplated that a particular physical field interface in the model may be selected with the corresponding study step settings, and then the corresponding set of partial differential equations may be solved one at a time in different study steps, or as a coupled system of partial differential equations, while solving the set of partial differential equations corresponding to multiple physical field interfaces.

Referring now to FIG. 12, there is shown an example model tree structure 1219 comprising one research node (e.g., "research 1" 1220) and several child nodes (e.g., "step 1: steady state" 1222 and "solver configuration"). In this example, the child nodes include a research step (e.g., "step 1: steady state," "step 2: transient state") and one or more solver nodes (e.g., "solver 1" 1224). Branches (e.g., study branch 1219) in the model tree structure may contain parent nodes (e.g., primary nodes) and child nodes (e.g., secondary nodes, child nodes). The study branch may include, for example, partial differential equation forms (e.g., "compile equation: steady state" 1226a, "compile equation: transient 2" 1226b) and solver settings (e.g., "steady state solver 1" 1228a, "transient solver 1" 1228b) for different studies (e.g., corresponding to each of steady state and transient analyses). It is contemplated that the user may select a subset of the physical field interfaces for solving the model in each study step, or all of the physical field interfaces for solving in each study step. It is further contemplated that the user may also contain a plurality of model nodes (e.g., model component nodes) corresponding to the physical field interfaces, the nodes representing the models described in the different spatial dimensions, and solving a subset of the physical field interfaces in each research step or solving all of the physical field interfaces in each research step. The selection of the physical field interface for each study step, and the setting of the study step, may also be included in the model object.

The solver branch (e.g., solver configuration) in the model tree structure example 1219 is a child node of the study branch (e.g., study 1), which can also include its own child nodes, such as a solver (e.g., "solver 1") and/or a dependent variable node (e.g., "dependent variable 1"). These child nodes may further contain additional or their own child nodes, such as "mod 1_ V" 1227a and "mod 1_ T" 1227 b. The user can further select whether to solve the variable in each research step in the dependent variable node, so the user can customize whether the solver solves a certain dependent variable in the physical field interface. It is contemplated that the selection of dependent variables at the solver step, and the setting of the solver step, may also be embodied in the model object.

The examples of modeling systems shown in fig. 3-12 are merely exemplary cases, and users will appreciate that modeling systems may be applicable to a wider range of physical processes and physical phenomena than those shown in the figures or described herein. For example, it should be understood that in the heat transfer case shown in FIG. 4, many different physical field interfaces may be calculated in addition to the selected physical field interface. As another example, it should also be understood that multiple views of equations may also be displayed in FIG. 7, and that many different material properties may also be selected in FIG. 8. The illustrated aspects are merely examples of the broader operations that may be performed by the multi-physics modeling system. Furthermore, the interfaces shown are merely representative of one type of interface that may be used in a multi-physics modeling system. Other graphical types, user types, or alternative input type interfaces are also contemplated.

Referring now to fig. 13-15, non-limiting illustrative flow charts 1329, 1439, 1549 include one or more methods for implementing the following: one or more partial differential equation set systems are automatically specified, represented as a single, coupled partial differential equation set system, and solved. Various aspects described in this disclosure document can be performed using an object-oriented programming language (e.g., a virtual machine language)C + +, C #), wherein the object is a type of data structure that contains data fields, methods, and their interactions. For example, objects in the model may be created, modified, and accessed by methods that call model objects. The model object may include algorithms and data structures for the model and may be further used to represent the model. The model object may further include methods for setting up and executing sequences of operations to create the geometry, mesh, and solution of the model.

It is further contemplated that the methods of the model object may be structured as a tree, and that such method calls may be associated with operations represented by nodes of the model tree. By operating on such a tree structure or model tree structure, a top-level method (e.g., represented as a parent node) can return references (e.g., represented as child nodes or otherwise) that support further methods. At some level within the model object, the method may perform some action, such as adding data to the model object, performing a calculation, or returning data. In the geometry node example (see, e.g., fig. 29), different operations associated with the model geometry may be contained in the model object, which are represented as secondary nodes (e.g., children) of the geometry node.

Referring now to FIG. 13, at step 1330, a modeling system user may select a spatial dimension either directly (e.g., actual selection) or indirectly (e.g., through steps associated with predefined features). The spatial dimensions can preferably be selected in a wizard window as previously shown in fig. 3 or through other types of interfaces. The selection of the spatial dimension includes an automatic update of the model object, which may be implemented by a model item containing the method call syntax model.

Next, at step 1331, one or more physical field interfaces may be selected. This selection or selections may be made through a wizard window as shown in FIG. 4. The selection of one or more physical field interfaces may include an update to the model object and the addition of a corresponding one or more physical items, model. Next, at step 1332, one or more types of one or more studies can be selected. For example, selection of a study may be implemented in a wizard window as shown in FIG. 5. It is contemplated that the selected study or studies may subsequently be used to automatically generate equations and solver settings. It is further contemplated that the model object may be updated by the corresponding study item, model. In some aspects, some or all of the created model object items may contain sub-items, which may be represented as nodes in a model tree structure. The nodes may describe operations specified in the model wizard and/or the setup window described above.

At step 1333a, it will be determined whether a physical field interface setting has been selected. If the logic determines true, the method will proceed to step 1333b, where it will be determined whether a further model is to be added. If another model (e.g., model component) is to be added to one or more components and/or processes already received by the modeling system (i.e., true), the method returns to step 1330 to receive input related to adding the model. A new model entry, model node (). create (), can then be added, containing the same or different spatial dimensions as the existing model. This would allow multiple processes to be simulated in one multi-physics model. If the model is not to be added further (i.e., false), the method proceeds to step 1440. If the logic of step 1333a determines false, the method will execute step 1334, where each physical field interface will be assigned a geometry, except for the zero-dimensional physical field interface, since the assigned geometry in such an interface will be a point. It is contemplated that one or more geometric representations may be created, or imported via a geometric file (e.g., a file created via a CAD system). It is further contemplated that the geometric model object may be updated to include a geometric representation.

At step 1335, the material and corresponding material properties will be specified. It is contemplated that the selection of materials and material properties may be performed by setting a window as previously shown in FIG. 8. It is further contemplated that the model object may be updated to a corresponding material item, model. Next, at step 1336, physical attributes of different domains, or different physical field interfaces, may be specified. It is contemplated that the setting of the fields may be performed by setting the window as previously shown in fig. 6. At step 1337, physical properties of the different physical field interfaces and interactions at the boundary may be specified. According to the idea, the boundary conditions are specified by setting the window as shown in fig. 9 hereinbefore. It is further contemplated that the domain settings and boundary conditions of the model object may be updated according to the model object item, model.

At step 1338a, a determination is made as to whether any partial differential equations of the physical field interface are to be modified. If the logic determines true, the method will execute step 1338b, at which point the predefined set of partial differential equations, including domain equations and/or boundary conditions, in some or all of the physical field interfaces may be modified. It is contemplated that in the step of modifying the system of partial differential equations, predefined physical field interface equations may be specified, for example, by setting windows as shown in fig. 7 and/or fig. 10 in the foregoing. Updates to the model objects may also be included in step 1338 b. If the logic determines false, or after performing the modify partial differential equation step, the method may return to step 1333 a.

After all of the physical field interfaces have been assigned, if the model is no longer being added to the component or components and/or processes being modeled, the method continues to the assign grid step shown at step 1440 in FIG. 14 (see FIG. 11). As contemplated, the specification of the grid may include updating a model object, model.mesh (). create (), by the grid entry. Next, at step 1441, a determination is made as to whether all of the required study parameters are included in the model. If the logic determines true, the method proceeds to step 1550. If the logic determines false, the method performs additional research and/or research steps. For example, at step 1442a, a determination is made as to whether to add a new study. If the logic determines true, the method will execute step 1442b in support of selecting additional studies. It is envisaged that additional studies, model. After completing the selection of additional studies, or if the logic of step 1442a determines false, the method proceeds to step 1443a, where it is determined whether one or more study steps are to be added. If the logic determines true, the method will execute step 1443b in support of adding one or more research steps to the model. Upon completion of the selection of one or more study steps, or if the logical determination of step 1443a is false, the method will execute steps 1444 and 1445, where the physical field interface of the study step will be specified, while the study step setup is completed. It is contemplated that study settings may be specified through a settings window as shown in fig. 11. It is further contemplated that the study setting may update the model object, model. After the study setup is complete, the method will execute step 1550.

Referring now to FIG. 15, at step 1550 a solver sequence is generated, at step 1551 a logical decision is made to determine whether the solver step is complete, and if so, the solver sequence is edited at step 1552. It is contemplated that the solver sequence can create a project, model. It is further contemplated that the solver sequence can be edited by items added according to model object items, model. Next, at step 1553, the method will solve the system of partial differential equations and generate a solution for the model. It is contemplated that the solving step can be updated by a model term, model.

Fig. 13-15 depict one or more non-limiting examples of methods for automatically forming one or more sets of partial differential equations associated with one or more physical field interfaces and geometric representations (e.g., models representing components or processes) in different spatial dimensions. It is contemplated that in some aspects of this method, the partial differential equations may be consolidated into a single combined partial differential equation system. Numerical solvers, such as finite element solvers, can be included in, for example, the modeling and simulation modules (e.g., 222) and used to solve a system of partial differential equations. For example, the finite element solver may solve a single system of partial differential equations corresponding to a single physical field interface, or may solve one system of coupled partial differential equations corresponding to multiple physical field interfaces and geometric representations.

Referring now to FIG. 16, a flowchart of method steps for creating or forming an application data structure (e.g., application object) is shown. The method may be implemented on any of the systems or devices described elsewhere in this disclosure. The user may perform the illustrated method steps through a user interface of an application developer module. In some aspects of the invention, the application data structures generated or created by the method can be loaded into (e.g., executed in) a multi-physics modeling system, such as the systems described elsewhere herein, to generate a customized application model that includes a corresponding application model tree structure for controlling selected settings in the multi-physics model. In some aspects, the resulting application data structure can include references to its own application-specific desktop design that, when loaded into (or executed in) the multi-physics modeling system, customizes the multi-physics modeling system desktop. The user is then able to access the application model in the user interface of the application itself.

Method steps for creating and forming the application data structure may begin with creating or selecting a multi-physics model 1600a, retrieving or loading a multi-physics model data structure (e.g., model object) 1600b corresponding to the method into an associated system. It is contemplated that in some aspects, multiphysics model data structure may be inline 1600c, i.e., an inline model that is the initial application data structure 1600 d. It is further contemplated that in some aspects, when the multi-physics model is saved or stored as an application file on a storage device, an initial application data structure containing the corresponding embedded model may also be created. In some aspects, the creation or formation of the application data structure can also include the act of adding geometric subroutines to the inline model 1600e (and to the inline model data structure). The added geometric subroutines can then also be embedded in application data structure 1600 d.

In some aspects, customized (e.g., application-specific) desktop features can be added or embedded into the application data structure. The desktop features can be represented as nodes in an application tree structure. Through execution of an application, the desktop feature is capable of displaying desktop windows including windows, controls, and forms. In some cases where an application is executed in a desktop of a multi-physics modeling system, desktop features may or may not be needed.

Next, at step 1620, another aspect of the steps for creating and forming an application data structure to which application features may be added is described. Application features may be represented by application nodes in an application tree structure. Application features can be used to add an application model node to an application model tree structure created from the resulting application data structure. Application model nodes in an application model tree structure may be specified to reference a setting in a model (e.g., a multi-physics model). When the application data structure is executed, application features can be added to the application model from controls or forms (such as buttons, combo boxes, or check boxes) in the application's desktop or window.

Application features are applied to the initial application data structure to create a custom application model data structure. Application features may be identified by type, description, and icon identifier. The type identifier is a unique identifier that can be used to point to an application feature in an application data structure, and can also be displayed alongside a feature in an application tree structure of an application developer module, such as in a GUI associated with a system running the application developer module. The description identifier may be displayed in a graphical user interface in the application model tree structure, or may be descriptive information of the operation represented by the application model tree structure node. The description or identifier can also be displayed in a control or form within a desktop or window as a substitute for a node in the application model tree structure. The icon identifier refers to an image file containing an icon graphic, and can also be displayed as an icon graphic in an application model tree structure or in a control or form when an application program related to the application program data structure is executed in a computer system.

In some aspects, application features may contain restrictions or preferences when defined, which may then be applied to corresponding application model nodes in an application model tree structure, or as a substitute for corresponding controls or forms within a desktop or window. For example, a constraint may be defined that an application model node may only be displayed after another node that is dependent on the operation that the previous node represented. In some aspects, the preferred conditions may be defined such that: an application model node, or control, or form will be displayed by default in an application model tree, or desktop, or window, or a node will be displayed as a singleton in an application model tree. In some aspects, such singleton nodes may only be added once to the application model tree structure, e.g., to define initial values or settings for initial conditions.

Next, in step 1630, an input declaration can be added to the application data structure. The input declaration is used to declare a new data box, where each data box includes a unique identifier, a name, an optional description, or a combination of the preceding items. Several types of input declarations are contemplated herein, for example, a string data box may be used to declare a string value, a string array data box may be used to declare a string array of any length, a two-dimensional string array data box may be used to declare a two-dimensional array of strings of any length at both the external and internal levels (e.g., an array element is still an array of arrays). As another example, a binary data box may be used to state that a data box may more efficiently store any data type in binary form (e.g., serialization). For example, a data box storing a large number of floating point numbers may be stored as a binary data box, although it may also be represented by other data boxes, such as an array of character strings. It is also contemplated that any data box in an embedded model may also be used as an input declaration (e.g., a model embedded in an application data structure). Such data frames may be parameters in the embedded model that are declared accessible to a user of the application created from the application data structure.

Next, at step 1640, the window, input form, and form collection can be added to an application data structure. It is contemplated that in some aspects, the input form represents a control or collection of controls that are responsible for monitoring different actions of the user as the application executes. Controls may include one or more elements of a graphical user interface that display information to a user or provide one or more ways in which a user interacts with an application, or controls may be short programs that describe the appearance, manner of operation, and how a particular element of a graphical user interface interacts with user actions. The input form can be added to a window or menu associated with an application feature. It is contemplated that the application developer module may include a predefined form template, a set of forms, and a set of controls that may be applied, for example, to create a settings window.

Some examples of input forms will now be described.

Text entry forms may include a text box linked to certain string data values, and are typically, but with exceptions, in the form of a text box. In some aspects, the link may assign a character string data value based on the received input to a text box, such as the received text input or the input received through a combo box. FIG. 25 also gives an example of a link in which input received through a text entry form may be associated with an internal data box of an inline model (e.g., an example parameter L for specifying actuator length). Fig. 34 is another example of such a link, which illustrates setting a value of one data box (e.g., impeller type box example 3405) by a combo box (e.g., impeller type box example 3426). It is contemplated that in some aspects, the settings of the combo box input form are similar to the settings of a text input form (e.g., FIG. 25).

The string data box value in the inline model may be selected in addition to any string data box object in the application feature. For example, such a string data value may be a model parameter. The combo box list may be used to display a selection list, which may include values for certain string data, such as a string data box. The settings may be similar to those of text entry. When executing an application, a check box may allow a user to select between two options, e.g., open or close. The button form may be used in a control collection and when selected by clicking or otherwise in an application, an operation may be performed. The menu item form may define a menu item in the menu in which it resides. Its parent node may be a menu or an application feature. When an application is executed, a menu item form with application features as parent nodes may be included in a context menu for the application features. The form entry form may be used to edit values in a string array data box declaration, typically with one column in the form representing a box reference.

The form collection may group some member forms to achieve the desired layout for the application user interface. The member form may be an input form or an output form (see below), and may also contain controls. Members of the form set can be added by referencing the input and output forms, or the input and output forms can be added directly as children of the form set (e.g., children in the model tree).

It is contemplated that in some aspects of the application developer module, several types of form collections may be used. A desktop window may be a collection of forms of one type and, in some aspects, the collection of desktop window forms may define a framework in the computer desktop in which other forms may be displayed, depending on the execution of the application.

When executing an application created by this application data structure, a field panel can be displayed within the desktop window or form window, and the field panel can be further associated with application features. Such a field panel may include a title bar (e.g., description) for the presentation, and a member form under the title bar. The form window may include at least one field panel, and it is further contemplated that the application feature may automatically obtain a field panel child node.

Another type of form set available in the application developer module may be a menu. One or more menus may be accessed through, for example, a toolbar in the desktop window when executing an application created by this application data structure, or the menu may also serve as a context menu for the application node. At least one menu item or other menu may be included in a sub-feature of the menu. In the application developer module, the menu may include one or more settings about its description.

The form set may also be another type of form set that is available in the application developer module. The form set may be used to combine several other forms into a new form. One such example includes the following: when an application based on the created application data structure is executed, several forms are displayed in a desktop window or a settings window in an overlapping manner with each other.

A card stack may be another type of collection of forms. When executing an application created by this application data structure, such a collection of forms may include several predefined forms that will be displayed based on the selection of the system user. It is contemplated that in some aspects, only one member of a form (and also a member of a card stack) may be active at a given time when an application containing such a collection of forms is executed. Which form in the stack of cards is to be displayed may be controlled by an activation condition, which will be described in more detail below. Other aspects of the form collection may include a desktop window. When executing an application created by this application data structure, the desktop window form collection may define a framework on the computer desktop for displaying other forms. The form window may be a specific, predefined desktop window type. The forms window may define a frame that displays other forms, which may be placed by row and column. The form window may further set a default window for the application associated with each application feature when executing the application created by this application data structure. Canvas windows are another specific, predefined class of desktop windows and are therefore a collection of forms. Upon execution of this application, the canvas window may be used to expose graphics such as geometry, grids, and drawings.

Next, at step 1650, an activation condition may be added to the input form or set of forms added in step 1640. The activation condition may be used to specify a logical condition for checking an input declaration value. For example, when an application is executed, the activation condition of an input form may be used to decide whether to enable or disable the form in the form window. The disabled form may be hidden in the window or grayed out to be inactive.

Next, at step 1660, an output declaration can be added to the application data structure. When an application is executed, the output declaration is used to declare data areas that cannot be changed by the user, but that can be read from the embedded model in the application or application data structure. For example, when an application based on an application data structure is executed, an output declaration can be used to declare the result from one computation of the inline model.

Next, at step 1670, an output form or set of forms can be added to the application data structure. The output form may represent any controls for displaying data in an output declaration, or objects representing data in an embedded model. The drawing group in the embedded model is an output form example, which can be directly used for canvas window. It is contemplated that, in some aspects, when executing an application based on an application data structure, the output form may be updated by one action (see below) to update and display the results of the previous action.

It is contemplated that in an application developer module for generating an application data structure, it may be desirable to define a plurality of output forms. The data of the output declaration may be displayed through a data display output form. The data display output form may also include a reference to a global computation in the embedded model added to the application data structure. When an application is executed, the globally computed values can be updated by performing such forms with some action. For large amounts of output data in an output statement, it is preferable to display the output form by a tabular data display. For example, one output reference may be used per column in a form. During execution of the application, the output form export action may open an export dialog box, saving the results as a file. Export output forms may be objects exported for addition to the embedded model of the application data structure and may include animations, images, and data.

Next, at step 1680, an activation condition may be added to the output form. Such activation conditions may be used to determine whether an output form is to be displayed. For example, when an application is executed, an activation condition may determine whether to enable or disable the output form in a form window. The disabled forms may be hidden in a window, or grayed out, when the application is executed.

Next, at step 1690, actions can be added to the application data structure. When executing an application created by this application data structure, the actions may include the definition of a sequence of operations and may be performed through an input form. For example, the definition of an action or sequence may be performed in response to an input form or according to a button or diagram selection. The action may also include an update to the output form. For example, the action may include an update to the embedded model drawing, which may then generate a new drawing in the application through a graphical window, such as a canvas window.

Next, certain aspects of step 1695 are contemplated. At step 1695, wizards may be added to the application data structure. This guide may be used to display a series of windows in the GUI in sequence or in some combination. The wizard may be placed directly below the application root node and may be launched when an application based on the created application data structure is executed or implemented to create a new model. In some aspects, a wizard may be set as a child of an application feature through which the wizard may be launched during execution of an application when a new instance is created. It is contemplated that in some aspects, the wizard may include at least one wizard step through the form of a child node. Such child node wizard steps may contain a specification of the window for each step in the wizard. For example, in some aspects, each wizard step may include a different window defined by the set up windows form.

Next, the method will continue to decide whether to determine or add other application features. If the answer is no, the method will proceed to step 16100, at which point the application data structure will be generated as output according to the method steps described above.

It is envisaged that in some aspects the application data structure will include as its embedded model the multi-physics model data structure on which it is based, together with a hierarchy characterizing the nodes generated by the above method steps.

It is further contemplated that the application data structure may be placed in a new or existing library when the updated or modified application data structure is deployed. A library may represent the actual folder structure in a file system or network. Any existing library may be accessed through a system configured or adapted to create one or more multi-physics model data structures from application data structures.

It is contemplated that the above-described methods for adding application features and generating application data structures are associated with a physical system model. It is contemplated that one or more application features, including one or more input claims, form features, activation conditions, and action features, may be represented as data to be added, obtained, received, or communicated as part of forming or generating an application data structure that is modified or updated and that includes the application feature.

Turning now to FIG. 17, an example of a Unified Modeling Language (UML) object diagram of an instance hierarchical relationship between features in an application data structure created using the course of actions described in FIG. 16 is shown.

The application data structure may include at least one inline model 1701 and at least one application feature 1702. Alternatively, the application data structure may include a desktop having desktop windows, forms, and controls. It is contemplated that one or more inline models and application features may also be included. The application data structure may include one or more (e.g., 1 …) input statements 1703, one or more input forms 1704, and the input forms 1704 may further include corresponding activation conditions 1714. The application data structure may also include 0,1, or more (e.g., 0 …) output statements 1705 and output forms 1706 at any location, and the output forms 1706 may further include corresponding activation conditions 1715. the application features 1702 may also include one or more (e.g., 0 …) sets of forms, which may include input forms and/or output forms. The application data structure may include 0,1, or more (e.g., 0 …) actions 1708, and the actions may further define 0,1, or more (e.g., 0 …) corresponding activation conditions 1716. In some aspects, the settings of the application features may also link to a wizard step 1713 included in the wizard features 1712. In addition, the application features may also include application sub-features 1709, which may also include sub-features. The application data structure may also include application sub-features 1709 that may be linked to the application features 1702, 1710 with corresponding wizard steps 1711. In some aspects, linking may be understood as introducing settings by way of a wizard, including setting up forms, activating conditions, values in text input, performing actions, and the like. In some aspects, the linking may be accomplished by setting a value of the string data. For example, the impeller type setup window example of fig. 34 may include a wizard step for linking the exemplary selection of the impeller and the impeller type and deciding whether to display an impeller tilt edit box.

Referring now to FIG. 18, therein are shown some operations in adding a multi-physics model data structure to an initial application data structure according to steps 1600 a-1600 d in FIG. 16, a corresponding application tree structure example. Right clicking or selecting the root node 1802 of the application tree structure opens or displays a context menu by which to add a multiple physics model data structure 1803 to the original application data structure.

The multi-physics model data structure may be selected through a model list of a multi-physics model library 1804 listed in the dialog box. This model library may come from the multi-physics modeling system itself, or may be a list of models previously created and saved by a user using the multi-physics modeling system. Such multiphysics models, and their corresponding multiphysics model data structures, may describe devices and processes that involve physical phenomena including static and quasi-static electromagnetic fields, time-harmonic and dynamic electric fields, acoustics, fluid flow and chemical reactions, heat transfer, structural mechanics, electromechanics, plasma chemistry and physics, fluid-solid coupling, thermal stress and expansion, electrochemistry, and other coupled physical phenomena and processes. It is contemplated that in certain aspects of the systems and methods described herein, exemplary application features may set time-harmonic electromagnetic field frequencies (inputs), run simulations (actions), display S-parameters (outputs) by running the model defined in the embedded model. As another example, by running an acoustic simulation embedded model, the exemplary application feature will receive input for updating the reference pressure, run the simulation, and display the wave propagation results. As another example, in a tank fluid flow model defined by the embedded model, the exemplary application features may receive an inlet flow rate, run a fluid flow simulation, and display an average flow rate at the outlet of the pipe. As another example, when running an electronics model in an embedded model, exemplary application features may determine the size (activation condition, output) of a heat sink that controls temperature under a given input value (input) at a given input load (input) through simulation (action). As another example, when running a model of a plasma reactor defined in a built-in model, exemplary application features would be used to receive values for a parameterized plasma reactor, make corresponding updates to the geometry (actions, activation conditions), and run simulations to calculate the coating thickness of the semiconductor material deposited on the wafer surface.

As another example, it is contemplated that an example of a micro-actuator model under a micro-electro-mechanical system (MEMS) module 1806 in a multi-physical modeling system may be selected. Once selected, the multiphysics model data structure can be represented as model node 1805 in the application tree structure, returning now to FIG. 16, with the model added to the application data structure per steps 1600c through 1600 d.

Referring now to FIG. 19, therein is shown an example of a corresponding application tree structure for adding certain operations in an application feature to an application data structure in accordance with step 1620 of FIG. 16. By right clicking or otherwise selecting the root node 1903 in the application tree structure, a context menu 1904 may be opened, through which an application feature may be added to the application data structure. Instead of a context menu, application features may be added by clicking on corresponding application features from a toolbar menu in the application developer desktop. In addition, in some aspects, when the application data structure is executed to create a new application, an application feature node, control, or form may also be included in the application as represented by a default. The application feature may be represented in the application tree structure as an application feature node 1905. The application features may be used to characterize settings in the device model example, such as micro thermal actuators, which may be further described by a multiphysics model data structure.

Referring now to FIG. 20, an example of a settings window 2006 for an exemplary application feature is shown, where the application feature is a setting in a thermal micro-actuator multi-physics model, according to certain aspects of a method of creating an application data structure. The setup window for the application feature may include type 2007, description 2008, and icon edit boxes 2009. Settings window columns, such as limits 2010, and preferences 2011 may also be included. In the preference column, a check box 2012 'add to permanent node' can be selected, and after the check, the node will always be displayed in the application tree structure during the application use process. Alternatively, a check box to add a permanent control or form may also be displayed. The singleton feature checkbox 2013 may also be used to specify that this application feature can only appear once in the application model when the application is running.

Referring now to FIG. 21, an example of a corresponding application tree structure is shown with some of the operations in adding an input declaration to the application data structure in accordance with step 1630 of FIG. 16. Right clicking or otherwise centering the feature node 2102 in the application tree structure may open a context menu 2103 through which input claims, such as a string data box 2104 or other available or listed input claim types, may be added to the application data structure. It is contemplated that such input statements may be used to receive input of parameters that are used to control settings in the embedded model during execution of the application.

Referring now to FIG. 22, an example of a corresponding application tree structure is shown for adding certain operations in a form set to an application data structure according to step 1640 of FIG. 16. Right clicking or otherwise selecting a feature node 2203 (or button in a toolbar) in the application tree structure (e.g., touching a screen, scrolling through a list, or hovering) may open a context menu 2204 through which an input form or set of forms, such as a field panel 2205, may be added to the application data structure. In such a context menu, other input forms or sets of forms may be included, e.g., a menu. There is also a default dashboard that can be used when creating an application. The field panel, or any other input form and set of forms, can be represented as a node in the application tree structure 2206.

Referring now to FIG. 23, an example of a settings window 2307 for a field panel form set is shown, in accordance with certain aspects of a method for creating an application data structure. In this example, only the title 2308 of the field panel may be contained in the field panel form settings window, but it is contemplated that the contents of the field panel form set may be defined by other sub-features. For example, the bar panel may be designed to receive input of the MEMS actuator length defined in the embedded model, so the bar panel title may be set to the actuator length 2308.

Referring now to FIG. 24, an example of a corresponding application tree structure is shown with some of the operations for adding a text entry form to an application data structure according to step 1640 of FIG. 16. Right clicking or otherwise selecting a feature node 2409 or other form collection node in the application tree structure may open a context menu 2410 through which to add child input forms to the field panel form collection in the application data structure. For example, the field panel may include a text entry form 2411 that may receive text entry for the length of the actuator in the inline model during execution of the application. The text input form may be represented in the application tree structure as node 2412.

Referring now to FIG. 25, an example 2513 of a setup window for a text entry form is shown, in accordance with certain aspects of the method for creating an application data structure. It is contemplated that such a setup window may include a data box reference 2514 pointing to data declared in the input declaration or previously declared in the inline model. For example, the text input may point to a parameter defined in the embedded model for controlling the length of the MEMS actuator. The settings window may also include a data box settings field 2515 that supports settings such as defining default values. Such default values may be displayed in an input edit box when the application is executed. In some aspects, a collection of ready-made controls for designing a text box is provided in the selectable controls column 2516. These selectable controls may contain descriptions 2517, symbols 2518, and units 2519. The control layout preview 2520 can display the manner in which the text box is displayed during execution of the application.

Referring now to FIG. 26, therein is shown an example of a corresponding application tree structure in which certain operations in adding activation conditions to an application data structure are performed according to step 1650 of FIG. 16. Right clicking or otherwise selecting text entry node 2602 or other entry form node in the application tree structure may open context menu 2603, in which add activation condition 2604 may be selected. In this example, when the application is executed, this condition may activate the text input form based on the value of the input parameter. This input parameter may be obtained from another input statement and input form, or reference a parameter in the embedded model. The activation condition may be represented in the application tree structure as a child of the input form.

Referring now to FIG. 27, therein are shown corresponding application tree structure examples, in accordance with certain operations of FIG. 16, steps 1660 and 1670, for adding a field plate and data display output form to an application data structure. It is contemplated that output declarations can be included in the inline model and linked to output forms by way of reference, as described below. Right clicking or otherwise selecting text entry node 2702 in the application tree structure can open a context menu for adding a collection of forms, such as a field panel that includes output forms. It is contemplated that such a dashboard may be represented as a node in the application tree 2703. Right clicking on or otherwise selecting the dashboard node 2703 may open a context menu 2704, in which an output form, such as a data display form 2705, may be selected for addition to the set of dashboard forms. When the application is executed, the data display form may be used to display values of derived values in the embedded model, or to display other data declared in the output form. In the application tree structure, the data display output form may be represented as a child node 2706 of the dashboard form collection node. It is further contemplated that in some aspects, an activation condition may be added to the output form, such as the activation condition described above in step 1680 of FIG. 16. Adding an activation condition to the output form is similar to adding an activation condition to the input form, as described for activation condition 2604 in FIG. 26.

Turning now to FIG. 28, an example 2807 of a setup window for a data display form is shown, in accordance with certain aspects of a method for creating an application data structure. Such a setup window may include an output data reference 2809 to point to data declared in the output declaration, or data already defined in the inline model in step 1650 of FIG. 16. For example, the data display form may reference a point calculation 2808 defined in the inline model, which is used to display the total displacement of the MEMS actuator. A ready-made collection of controls for designing a data display form is provided in selectable controls column 2810. These selectable controls may include descriptions 2811 and symbols 2812. The control layout preview 2813 can display the manner in which the data display form is displayed when the application is executed.

Referring now to FIG. 29, therein is shown a corresponding application tree structure example, with some of the operations in the add action to the application data structure in accordance with step 1690 of FIG. 16. Right clicking or otherwise selecting an application feature node in the application tree structure may open a context menu 2903, in which add actions 2904 may be selected. It is contemplated that this action may be represented as a node in the application tree structure 2905. In some aspects, one action is to perform a sequence of operations in the embedded model.

Referring now to FIG. 30, an example of a setup window 3006 for action features is shown in accordance with certain aspects of a method for creating an application data structure. It is contemplated that such a set window may include a copy 3007 of an exemplary model tree in the inline model, where an action may be linked or associated to an operation in the inline model. For example, the motion features may be linked or linked to a sequence of operations 3008 for generating actuator geometry, as well as operations that simulate the total displacement of the MEMS actuator in an embedded model.

Referring now to FIG. 31, an example of a corresponding application tree structure is shown, according to some of the operations in another example of adding a menu form to an application data structure at step 1640 of FIG. 16. Right clicking or otherwise selecting the application feature node 3121 in the application tree structure may open the context menu 2903 from which the menu form 3122 may be selected for addition to the application features. The menu form may be a menu item in a context menu that will be displayed when the application feature is selected during execution of the application. The menu form may be linked to an action that will be performed when the context menu item is selected during execution of the application. An action may refer to performing a sequence of operations in the embedded model, for example, linking to the exemplary geometry sequence 3008 in FIG. 30. It is contemplated that such action links may be created by selecting an action in a menu form settings window.

It is contemplated that in certain aspects of the present invention, the terms link and association are used interchangeably to refer to an associative relationship between two units or features as understood in the art of computer modeling. In some aspects, a link may further be understood as an instance of an associative relationship, such as when an application is executed in a modeling system.

Referring now to FIG. 32, an example graphical user interface 3206 is shown in accordance with certain aspects of an application developer system or module that creates or forms a blender application data structure. In the application tree structure of the exemplary application developer, there are included a representation 3207 of the embedded multi-physics model and five exemplary application features that define the user interface of the resulting blender application. The blender application may include application features to define the container 3214, impeller 3215, liquid type 3216, blender operation 3217, and simulation results 3218, among others.

The embedded multi-physical field model may include geometric definitions, material properties, physical fields, meshes, solvers, and solution results of the blender model. Based on momentum and mass conservation law of a physical field interface of a multi-physical field modeling system, the embedded stirrer model can solve a fluid flow problem aiming at a stirrer with a rotating impeller. In addition, the multi-physical field model can be further customized, and the concentration field of one or more chemical substances in the stirrer solvent can be solved.

Referring now to FIG. 33, wherein an input for creating a container geometry is received in accordance with some aspects of a container application feature 3319, namely in a method of creating an application data structure, a tree structure of corresponding application features is shown. The application tree structure may characterize the contribution of container application features to the application data structure of the blender application. The container feature may set a node with a corresponding set window in the model tree and will display the node during execution of the application. The setup window may include a container specification bar panel 3323, which in turn includes two input forms; one for a given container height 3324 and one for a given container diameter 3325. The input forms can point to parameters in the embedded multi-physical field model, the container geometry in the multi-physical field model is represented by the parameters in the execution process of the application program, and the height and the diameter of the container can be changed according to user input.

The following systems and methods have been described herein (with reference to fig. 16 and 17 and associated exemplary GUIs): these systems and methods create an application data structure based on a multi-physics model through a graphical user interface (e.g., a specialized GUI) in application developer software that is structured to access features and feature settings for the multi-physics model. Such a graphical user interface may also provide a method for generating data structures representing applications by using existing settings of a multi-physics model. The application data structure is then deduced (e.g., executed) by another method to enable it to be accessed through a GUI in a multi-physics modeling system that generates the application model data structure and the multi-physics model data structure for simulation.

Preferably, the flexibility and range of capabilities of the geometry subroutine and accumulation options are expanded to allow the geometry subroutine to become more reusable and more powerful. For example, the geometric subroutine may be expanded to accept objects and selections as input. Furthermore, by defining cross-sections in a working plane in a multi-physics modeling system, the definition of cross-sections of the geometric subroutines exemplified in the waveguide application illustrated and described in fig. 37a to 37c can be achieved.

Referring now to FIG. 34, an example of a tree structure for a vane application feature is shown, in accordance with certain aspects of creating an application data structure. It is envisaged that the impellers may be of different types, for example, six-bladed turbine blades (Rushton), three-bladed pitched blade blades, or four-bladed pitched blade blades. Thus, the impeller characteristic may include an impeller type parameter or string declared by the impeller type input declaration characteristic 3405. The values for the impeller type parameters may be obtained from an impeller type combo box input form 3426. The valid value feature 3427 may be a sub-feature of the combo box input form that may display the selected value in the combo box input form during execution of the application.

It is contemplated that in some aspects, the value of the impeller type may be used as an if-statement feature input in a geometric sequence in the embedded model. Such if-statements may be used to decide which impeller type may provide a better design and therefore which impeller type should be constructed or implemented. The non-limiting exemplary aspect illustrates that the geometric subroutine is extended to accept objects and selections as input, for example. The customization of the application for the multi-physics model enables the model to be defined and simulations to be performed for a particular physical system, such as the exemplary impeller aspect of the illustrated blender application. The customization of the application also enables the design of the physical system being simulated (e.g., blender, waveguide, other) to be optimized and provided as input to one or more computers used to control the manufacturing process of the physical system, and, by extension, to machines cooperatively associated with such one or more computers.

In addition, each impeller type may also receive parameter inputs from the impeller and container input form, such as impeller diameter 3428, clearance 3429 from the bottom of the container. Some of the input forms may also include an activation condition 3402. For example, if a pitched blade impeller is selected, an edit box 3430 for entering the impeller pitch angle will be displayed. If the user selects the pitched blade impeller while the application is executing, the activation condition will be activated and the text entry box will be displayed.

In some aspects, the application feature tree structure can also include nodes that represent actions in the application data structure. For example, for the impeller application feature 3420, the "build impeller" node 3409 represents an action in the application data structure. After the exemplary impeller application is executed, it is contemplated that the actions defined in the inline model can include: execute the geometry sequence, determine the result of the if statement, and/or execute a geometry subroutine call for the impeller geometry.

Referring now to FIG. 35a, geometric operations and selections that may be performed according to an input geometric subroutine for exemplary impeller application features are illustrated in accordance with certain aspects of creating application data structures and executing applications. Using action features in application features, a geometric subroutine may be called from a geometric sequence, and such a call may be characterized as a node in a model tree, such as a node of a geometric branch in an embedded model. The impeller type is determined by if statements, such as the six-bladed impeller 3500, the three pitched blade blades 3501, and the four pitched blade blades 3502 described above, the geometric subroutine may run a geometric parameterization sequence for the respective impeller type. Other systems and objects capable of running geometric subroutines are envisioned, with the impeller illustrated as an example for creating an application data structure and executing an aspect of the application.

The output of the geometric subroutine may be the geometry of the impeller and a set of choices corresponding to the shaft surface 3503, the impeller surface 3504, and the surface 3505 between the impeller 3506 and the container domain 3507 defined in the inline model. Each selection group may be used to set boundary conditions for the physical field in the embedded model when the application is executed. For example, when the particular boundary condition of the flow equation is derived from impeller rotation, the selected set of impeller surfaces is easier to operate. Furthermore, in one example, the interface of the cylinder around the impeller requires the use of a moving grid setting, such as using the lagrange-euler method (ALE) to simulate rotation of the impeller.

The geometric subroutine can define a set of local parameters that receive their values from the geometric subroutine reference (refer to fig. 35c) or dependent on the geometric subroutine reference. In turn, the geometric subroutine arguments can reference parameters that are external to the geometric subroutine. In addition to global parameters (e.g., parameters defined both inside and outside of the geometric subroutines in the embedded multi-physics model), the representation of geometric features in the geometric subroutines can include arguments and local parameters. In case of conflict, consider that the arguments and local parameters of the geometric subroutine take precedence over the global parameters. In some aspects, the geometric subroutines can also include their own native functions. For example, these local functions can be used to define functions that depend on subroutine arguments.

Referring now to FIG. 35b, exemplary geometric subroutines representing model trees in an inline model in application developer software are illustrated in accordance with certain aspects of the illustrated method and system for creating application data structures. An inline blender model, such as the one illustrated above in the application illustrated in fig. 35a, can include a geometric subroutine of a pitched blade impeller 3515, a turbine paddle (Rushton turbine)3516, a dish-shaped bottom vessel 3517, and/or a flat bottom vessel 3218. The arguments are instantiated via geometric subroutines of turbine buckets 3516 and include an argument list 3519, a set of parameters 3520, and/or a set of output selections such as a disk selection 3521 for disks in the turbine buckets.

It is contemplated that the geometric operations in the geometric subroutine may also create output choices that may facilitate additive selection such as a merge operation for the impeller's agitator shaft and coupling (see element 3522). The turbine paddle geometry subroutine can be called in the geometry sequence in geometry subroutine call 3523, and in some aspects, the turbine paddle geometry subroutine may only be called when the impeller type is turbine paddle, with the if statement in the geometry sequence including the geometry subroutine call 3523.

Referring now to FIG. 35c, a setup window including an argument list is illustrated in accordance with certain aspects of the illustrated method and system for creating geometric subroutines in an embedded model in an application data structure. The argument list comprises parameters that can control the dimensions of the object created in the geometry subroutine. In an exemplary aspect of the turbine paddle geometry subroutine, such parameters can directly or indirectly control the dimensions of the impeller. For example, the arguments can control the impeller diameter 3225, impeller shaft diameter 3226, vessel height 3227, vessel diameter 3228, gap 3229 from the vessel bottom to the impeller, blade length 3230 of the impeller, blade width 3231, and/or others (e.g., blade pitch, number of blades, handedness). These arguments are exemplary, and it should be understood that the geometric subroutines and argument lists can be applied to many other applications that include geometric aspects.

Referring now to fig. 35d, an exemplary setup window for the geometry subroutine call 3532 (also referred to as a geometry sequence call) is illustrated for the turbine paddle geometry subroutine illustrated above. It is contemplated that different geometry subroutines can be invoked by different selections, for example, via drop down list 3532, or by browsing to a linked geometry subroutine as will be further described below. It is contemplated that the values of the arguments of the geometric subroutine described above can be set in the geometric subroutine call 3533. It is also contemplated that the output choices can be listed according to the following geometric entity levels: objects, domains, boundaries, edges, and/or points. For example, the output selection of boundary 3534 can be used in an in-line model to define different boundary conditions on different boundaries. For example, the disk selection can contribute to the rotating inner wall selection 3235 for each boundary condition. The selection of Rushton paddle agitator shafts and couplings can aid in the selection of rotating wall conditions 3536 and/or Rushton blade selection can aid in the selection of rotating inner walls 3537.

It is contemplated that the geometric subroutine may be capable of accepting selections associated with input geometric objects and input geometric entities such as domains, boundaries, edges, and/or points. The input selection nodes in the geometry subroutine branches of the model tree can be utilized to represent input selections of geometric objects and geometric entities. The first time an input selection is added, an input selection feature may be added at the beginning of a geometric subroutine branch in the model tree. The input selection feature may be associated with a settings window as follows: the set window comprises a geometric entity level combo box used for selecting from objects, domains, boundaries, edges and/or points; and/or a read-only list of selected objects or entities. When an input selection feature is selected, a corresponding selection may be highlighted in a graphical window of the multi-physics modeling system. In one exemplary aspect, an input selection may receive as input a boundary selection and with this boundary selection, a complex object is created by highlighting and clearing the boundary in the selection according to the geometric sequence specified in the geometric subroutine.

In some aspects, it is contemplated that each feature represents an object or geometric operation in a geometric sequence of geometric subroutines. For example, the "cylinder 1" node 3530 under the exemplary turbine paddle geometry subroutine 3516 in fig. 35b defines an impeller shaft geometry or merge operation 3522 that unites the impeller's stirring shaft and coupling. The geometric operation settings can also include a check box or another selectable option to create an output selection. In some aspects, output selections are available in the geometric sequence, and can also be external to the geometric subroutine.

Referring back to FIG. 35d, geometric subroutines can also be created by linking to geometric subroutines in other multi-physical field model files 3532. The name of the linked geometric subroutine node may be constructed from the file name and subroutine name in the file referenced by the linked subroutine. The setup window for the geometric subroutine of a link can include a read-only filename text box including a relative or absolute path to the file referenced by the link, a check box to select a relative or absolute path, a read-only subroutine text box, and/or a sync button. The synchronization button is capable of performing any changes made in the file referenced by the linked geometry subroutine.

It is contemplated that the definition of the linked geometric subroutine can appear or be displayed, but such appearance or display may be in a read-only state (e.g., grayed out in the user interface). The local parameters can include global parameters from a file referenced by the linked geometry subroutine. The linked geometric subroutines may not use global parameters defined in the model in which the link was created. The local function may include a global function from a file referenced by the linked geometry subroutine. The linked geometric subroutines may not use the global functions defined in the model created with the links.

Referring now to FIG. 36, an exemplary application tree structure for a waveguide application is shown, in accordance with certain aspects of creating an application data structure. The waveguide may include straight and curved segments. The first application feature is waveguide generic feature 3621, which includes a set of forms and actions that define the waveguide cross-section during execution of the application; operating conditions, such as frequency; output specifications corresponding to the content displayed in the output form, such as real or imaginary (if complex) values, db (decibel), S-parameters (scattering parameters). Straight segment application features 3622 may include a set of forms and actions 3631 specifying the length of the segment, and an action 3614 constructing the segment. The corresponding curved segment application features 3623 may include a set of forms and actions 3632 for specifying the direction and radius of the curve.

When executing applications applied to these action features, such as creating segment features 3613, the straight and curved segment features of this waveguide application may also be used to create corresponding geometric features in the multi-physics model data structure of the embedded model. Accordingly, if the user chooses to remove during execution of the application, the geometric feature may also be removed from the embedded model geometry sequence. In addition, a second action, such as adding an object selection feature, may increase the selection created by the added waveguide segment and act as a contribution to the cumulative segment set defined in the embedding model, as will be described in more detail below.

Referring now to FIG. 37a, therein is shown an example of a model tree and waveguide geometry. The model tree and geometry are created by a waveguide application, which includes geometric subroutines that are interpreted from an application data structure in a multi-physics modeling system. When the application program is executed, the waveguide segment is added, so that the geometric characteristics and the multi-physical-field model data structure corresponding to the model can be added to the embedded model. The geometric subroutine of each segment may be called through the geometric sequence of the embedded model. It is contemplated that such geometric subroutines may receive parameters from the waveguide cross-section 3711 of the waveguide setting 3708. The straight segment subroutine may receive input on the waveguide length from the straight segment feature 3709, and the curved segment may receive the direction of the cross-section and the radius of the curved segment from the left/right segment feature 3710. In addition, any straight or curved segment subroutine may also receive an index, prompting whether there is a previous geometry subroutine call in the geometry sequence. In the case of other segments before, the geometry subroutine may also receive the start position of the respective waveguide segment, wherein the end position of the previous segment may be used as the start position of the next segment.

Each geometry subroutine may output the geometry of the corresponding segment, the selected wall set 3712, and the domain 3713 of the waveguide. The output may also include an index (1 for the first segment, 2 for the second segment, etc.) to show the waveguide's current segment index, and the end position 3714 of the waveguide segment may be used as the starting position for the next segment. If there are multiple segments, each geometric subroutine may treat itself as a contribution to the domain and wall selection, thereby creating an additive selection from the contribution of each waveguide segment.

Referring now to FIG. 37b, an exemplary model tree in an embedded model of a waveguide application is illustrated, in accordance with certain aspects used to create or form an application data structure. An exemplary embedded model for the waveguide includes geometric subroutines of waveguide cross-section 3738, straight waveguide segment 3739, and left/right curved segments 3740. It is contemplated that the geometric subroutine receives a start plane from a previous waveguide segment that allows a new segment to be geometrically connected to an existing waveguide segment. The geometry subroutine may also be capable of creating an end plane 3742, which end plane 3742 may be used as a start plane for a waveguide segment added after the current waveguide segment. For example, if there are no general boundaries (or domains, edges, and points), then the selection of geometric entities can be used as input selections in a similar manner. An exemplary geometric subroutine can include a cumulative output selection. For example, the accumulation output selection can be used for domain setting of the Electromagnetic (EM) region 3743, boundary condition setting of the electromagnetic wave input boundary 3744, and boundary condition of the electromagnetic wave output boundary 3745.

Referring now to FIG. 37c, an example of a setup window for a geometry subroutine call (also referred to as a sequence call) is illustrated in accordance with certain aspects used to create or form an embedded model geometry in an application data structure. To connect a new waveguide segment to a previous one, a geometry subroutine call, such as "sequence call 2" of "geometry 1" in fig. 37b, can include a reference to end plane 3746 in previous geometry subroutine call 3747 to be used as start plane 3748. It is contemplated that the features illustrated in the context of the waveguide example can be applied to other setup windows for other geometric forms.

Referring now to FIG. 38, an example of a graphical user interface 3833 for designing input forms, output forms, and form collections in an application developer system or module is shown, in accordance with certain aspects of creating an application data structure. The exemplary graphical user interface 3833 supports interactive drawing and positioning of input and output forms, and interactive design of: the set of forms 3834a and 3834b, the set of controls that include tabs 3835a and 3835b, text boxes 3836a and 3836b, combo boxes 3837a and 3837b, check boxes 3838a and 3838b, and other forms and controls. Alignment may also help the user of the tool locate forms and controls. A toolbar 3839 is further contemplated, which may include buttons and control node display or augmentation in the model tree instead of a context menu.

When a form or control node is selected in the application tree, such as text box 3836a, its layout may be displayed in the graphic developer window to support interactive positioning of the corresponding form or control collection. In the settings window for controls and form features, an additional layout column 3840 may be displayed. In this layout column, the value of the layout information can be set; for example, the position 3841, width 3842, and height 3843 of the form or control. These values may be automatically updated based on interactive changes to the graphical developer window.

It is contemplated that relative positioning may be used in the form when creating the application data structure. For example, a first form or control may be placed anywhere in the collection of forms, and other forms and controls will typically be placed with vertical or horizontal alignment depending on its position. Further, in some aspects, vertical alignment and horizontal alignment may be independent of each other, and each form or control may contribute several lines of vertical and horizontal alignment. All forms or controls may contribute a horizontal alignment line through their left borders. In addition, fixed width forms or controls, such as buttons, combo boxes, and text boxes, may also contribute a horizontal alignment line according to their right borders.

It is contemplated that a preferred line spacing may also be specified for the graphic developer window, the line spacing typically having a default value. In some aspects, the default line pitch is about 5 pixels. The line spacing may specify how much space should be from the bottom of one form or control to the top of another. And may also be used to decide where in the row directly below the current form or control the form or control should be placed. The line spacing may contribute to a vertical alignment line above or below the form or control, making it easier to insert a new line above or below an existing control to place the form or control.

When a user of the application developer system moves or resizes a control (e.g., resize processor 3844), the alignment line may attempt to align the left boundary of the control with the left boundaries of other controls, or the right boundary of the control with the right boundaries of other controls, while also performing similar operations in the vertical direction. When the control is moved or resized, a vertical and/or horizontal alignment line may be drawn in the graphical developer window while the alignment operation is being performed. The aligned hot spot area can be 6-7 pixel units in each direction of the alignment line, so that the hot spot area can be moved out of the hot spot area of any alignment line and can be freely placed even in the alignment operation.

It is envisaged that selection in the application tree structure and the graphic developer window may enable bi-directional synchronization. If a form or control node is selected in the application tree 3836a, the corresponding form or control in the graphic developer window 3836b will also be selected, and vice versa. Since multiple forms and controls can be selected in the graphic developer window, but only one set of settings for a form or control can be included in the settings window at a time, changes to their width and height can also be controlled via the toolbar. When multiple forms or controls are selected, the following operations may be implemented via the toolbar buttons: aligning or centering the selected form or control left, right, up or down; distributing the controls at the same horizontal or vertical spacing; the controls are given the same width or height. It is also contemplated that the display names of the tabs, check boxes, buttons, etc. can be changed by double-clicking on the form or control in the graphic developer window, and new text can be entered within the form or control. Copy and paste operations are also supported to reuse the configuration of forms and controls in another collection of forms.

The graphic developer window may also automatically create rows and columns. For example, a new column may be automatically inserted at the left border and a new row at the upper border of each form or control. Because alignment is used when drawing forms and controls, only a few rows and columns need to be created. Depending on the width and height of the form or control, it may span several rows or columns. If several forms or controls in a column are the same width as the widest form or control in the column, these forms and controls may be set to fill the column. This may help align the right borders of several text boxes and combo boxes into a neat column. The automatically created rows and columns may also be individual elements in the graphic developer window that may be selected by entering a certain selected mode. The selected row may be interactively moved up and down to other rows. For the selected column, the application developer user can specify a fixed width, or when resizing, the width fits the width of the top-level form. There may also be some tools for inserting lines, deleting lines, in order to make room for adding new lines, or deleting all forms or controls in a line and compressing the layout accordingly.

The form collection may include many forms and controls, and as new forms and controls are added to the form collection, the form layout may become quite complex. In this case, it is preferable to divide the form set into several form sets, each having a separate layout management, and then to use the form sets as child form sets of the original form. In this case, it may be possible to encapsulate several forms and controls in a form collection using a rectangle, and then specify, via the extract forms tool 3845, that these forms and controls should be extracted into their respective form collections.

Referring now to FIG. 39, in an application data structure for generating and maintaining application model trees, context menus, and settings windows in a multi-physics modeling system, this figure shows a flowchart illustration of a method in accordance with some aspects thereof. The interpretation method may further be used to generate an application model data structure according to settings specified by a user of the multi-physics modeling system. At step 3910a, a list of applications is determined and displayed from the list of available application data structures 3910 b. Next, at step 3920b, the user selects an application from the displayed menu list, whereupon the application model is added to application model data structure 3920 b.

After determining to add application model features, the flow of FIG. 39 proceeds to step 3930a, at which point an application model tree with a context menu including application model features is determined and displayed based on the definitions of the available application features in the application data structure 3930 b. Next, at step 3940a, the user has selected application model features. This selection will determine the application model features to be used in later method steps, as well as add the application model features to the application model data structure 3940 b. Next, at step 3950a, a setup window for application model features will be determined and displayed based on the definition of application features available in the application data structure 3950b in the user input. Then, at step 3960a, the user may edit the settings in the settings window for the application model features. The default settings and the modified settings will then be saved in the application model data structure 3960 b. Then, if no further application model features are to be added, the application model data structure will be completed at step 3980.

Turning now to FIG. 40, an example application selection window 4000 for displaying an application menu according to certain aspects for interpreting application data structures is depicted. Selecting an application, such as the thermal actuator application 4009, creates a first version of the application model data structure. An application user may edit the application model data structure through an application user interface.

A variety of different applications may cover numerous areas of modeling and simulation. By applying the processes and systems described in this disclosure document, application data structures and application model structures can be formed or created, and the resulting applications can be used for problem-specific modeling and simulation analysis, motor 4001, fuel cell stack 4002, speakers 4003, waveguides 4004, mixers 4005 for fine chemicals and food industries, multi-tube heat exchangers 4006, plasma reactors 4007, and pressure piping 4008, to name a few.

Referring now to FIG. 41a, an application model tree window 4100a is shown including a display menu of application model features, such as a thermal actuator feature 4110a in a thermal actuator application, and a corresponding context menu 4120a, according to some aspects for explaining the application data structure. Upon selection of the heat actuator feature 4110a, a settings window 4130a will be displayed where the application user can edit the heat actuator settings, such as length 4140 a. Upon selection of the run simulation option 4150a in the context menu of thermal actuator features 4120a, a final application model data structure may be created, the final model data structure in the multi-physics modeling system interpreted, and the simulation executed. It is contemplated that the application model data structure may be interpreted (e.g., executed) in a multi-physics modeling system to generate simulation results. The simulation results may be displayed in an output form. For example, the displacement result 4160a of the thermal actuator may be displayed in the setting window 4130 a.

Referring now to FIG. 41b, an exemplary application model tree window 4100b is illustrated that includes a display menu of application model features, such as a paddlewheel feature 4110b in a blender application and a corresponding context menu 4120b, in accordance with certain aspects of the method used to interpret the application data structure. Upon selection of the vane feature 4110b, a settings window 4130b will be displayed where the application user can edit the settings of the vane. For example, the type, which has been previously defined at element 3426 in fig. 34, can be edited in the corresponding combo box 4140b, together with the parameter value to set the impeller type 3405. In certain aspects, upon selection of "build geometry" 4150b in the context menu 4120b of exemplary impeller features, an action can be performed, such as a build impeller action from element 3409 of fig. 34 for a geometric sequence in an inline model. For example, the action can execute an if statement to build the selected impeller type (e.g., when the impeller type is built when running the application, if the impeller type is Rushton, the Rushton geometry subroutine is referenced) (e.g., element 3524 in fig. 35 b), call the corresponding geometry subroutine (e.g., element 3523 in fig. 35 b), and add the geometry specification and its cumulative selection to the application model data structure (e.g., an instance of an application data structure that includes an instance of an embedded model data structure).

Turning now to FIG. 42, an example of a Unified Modeling Language (UML) object diagram showing an example hierarchical relationship between features is shown, in accordance with certain aspects of the application model data structure created by the method steps in FIG. 39. Application model data structure 4201 may include the entire multi-physics model data structure upon which the application is based, as well as a reference to application data structure 4211. In addition, the application model data structure may also include a hierarchy to characterize the user's added application model features 4203. Each node may include a reference to an application feature in application data structure 4204. If supported by application data structure 4206, application model features may include other application model features as its child nodes 4205.

Referring now to FIG. 43, an example flow diagram of a method is shown in accordance with certain aspects of interpreting an application model data structure and generating a multi-physics model data structure including model objects. The method shown is a step prior to discretizing and solving equations in a multi-physics modeling system. At step 4310a, an application model is determined from application model data structure 4310 b. Next, at step 4320a, application model data structure 4320b is loaded onto the interpreter. Then, at step 4330, the execution sequence of the application model data structure will be processed. At steps 4301 and 4302, an execution sequence is processed and executed. Further, the sub-execution sequence may also be processed at step 4303. After all execution sequences have been processed, a multi-physics model data structure is generated at step 4340.

In some aspects, a device for generating an application data structure may comprise a physical computing system comprising one or more processors, one or more user input devices, a display device, and one or more storage devices. Wherein the at least one storage device includes executable instructions for generating the application data structure. The multiple physical field model data structure of the physical system is embedded into the application data structure by executing the executable instructions on at least one processor. The embedded multi-physics model data structure includes at least one modeling operation of the physical system, running on at least one processor to determine one or more application characteristics, added to the application data structure. The one or more application features are associated with a physical system model, and first data representing at least one form feature of the application features of the physical system model is augmented via the at least one input device. Adding, via the input device, second data representing at least one action characteristic of the application characteristics of the physical system model, the second data representing the at least one action characteristic associated with at least one modeling operation of the physical system to define a sequence of operations for modeling the physical system. The application data structure will be modified. The modified application data structure including the added first data, second data, and a definition of a sequence of operations associated therewith is stored on the at least one storage device.

In certain aspects, a method performed on a computer system including one or more physical computing devices is used to modify an application data structure to enable modeling of the physical system. The method includes embedding, by one or more physical computing devices, the multi-physical field model data structure into an application data structure stored in one or more storage devices. The embedded multi-physics model data structure includes at least one multi-physics modeling operation. One or more application features to be added to the application data structure are determined by executing on the at least one physical computing device. The application features are associated with a physical system. Application data representative of the one or more determined application characteristics is obtained by at least one of the one or more physical computing devices. The application data includes form data representing at least one form characteristic of the modeled physical system, and action data representing at least one action characteristic. A modified application data structure including the retrieved application data will then be formed. The modified application data structure is stored on at least one of the one or more storage devices. Application data representing at least one action feature is associated with at least one modeling operation of the physical system defined in the embedded multi-physics model data structure. The association between the action data and the at least one modeling operation defines a sequence of operations for modeling the physical system.

It is contemplated that the apparatus for generating an application data structure and method for generating a modified application data structure for modeling a physical system described above may, in certain aspects, further include one or more of the following features. In determining the one or more application features, one or more application feature selections received from an input device associated with a graphical user interface for displaying the application features may be included. In obtaining the application data, one or more application data received from an input device associated with a graphical user interface for displaying application feature options including form features and action features may be included. The defined sequence of operations may be configured to generate a geometry of the physical system. In forming the modified or updated application data structure, an embedded multi-physics model data structure may further be included. The apparatus and methods may further include outputting the modified or updated application structure as an input data structure configured to be received and executed via the multi-physics modeling system. Application data representing one or more application features may further include declaration data defining an input declaration for the physical system being modeled, the declaration data including settings for controlling a physical component in the physical system of the embedded model in the multi-physical field model data structure.

It is further contemplated that the apparatus for generating an application data structure and the method for generating a modified application data structure for modeling a physical system described above may, in certain aspects, further include one or more of the following other features. Form data representing at least one form feature may include data defining an input form for collecting parameter input for an input statement. Form data representing at least one form feature may further include other data defining parameter inputs used to collect activation conditions. Application data representing one or more application features may include data defining an output declaration for declaring a display of results after a simulation of an embedded model in a multi-physics model data structure is complete. Form data representing at least one form feature may include data defining an output form for displaying a result declared in an output declaration. The form data representing at least one form feature may further include other data defining an output activation condition for the output form. The apparatus and methods may also include an act of characterizing the application data structure that is modified or updated in the application tree.

In some aspects, a system may generate a modified application data structure. The system includes one or more physical storage devices, one or more display devices, one or more user input devices, and one or more processors configured to execute instructions stored on at least one physical storage device. The instructions are to cause at least one of the processors to perform the following operations by one or more physical computing devices: a multi-physics model data structure is embedded in an application data structure stored on a storage device. The embedded multi-physics model data structure includes at least one multi-physics modeling operation for the physical system being modeled. One or more application features to be added to the application data structure are determined by at least one of the one or more physical computing devices. The one or more application features are associated with a physical system. Application data representative of the determined one or more application characteristics is obtained by at least one of the one or more physical computing devices. The application data includes form data representing at least one form characteristic of the modeled physical system, and action data representing at least one action characteristic. A modified application data structure is then formed containing the retrieved application data. The modified application data structure is stored on at least one of the one or more storage devices. Motion data representing at least one motion feature is associated with at least one modeling operation of the physical system defined in the embedded multi-physics model data structure. The association between the action data and the at least one modeling operation defines a sequence of operations for modeling the physical system.

It is contemplated that the system for generating a modified application data structure described above may in certain aspects further include one or more of the following features. The application data obtained may include application data received from one or more input devices associated with a graphical user interface for displaying application feature options. These feature options include form features and action features. The defined sequence of operations may be configured to generate a geometry of the physical system. The system may also further include outputting the modified application structure as an input data structure configured to be received and executed via the multi-physics modeling system. Application data representing one or more application features may further include declaration data defining an input declaration for the physical system being modeled, the declaration data including settings for controlling a physical component of the embedded physical system model in the multi-physical field model data structure.

In certain aspects, a method performed in a computer system includes one or more processors configured to generate an application model data structure that models a physical system. The method includes determining, by one or more processors, a plurality of actions for modeling one or more physical system applications. The applications are determined by application data stored in one or more application data structures. The applications display a list of these applications in one or more graphical user interfaces. A first input indicating that at least one application of the selected plurality of applications has been received. Then, for at least one of the selected plurality of applications, one or more application characteristics are determined by at least one of the one or more processors. The one or more application features are characterized as application data defined or retrieved in at least one of the one or more application data structures. The determined application features are to be displayed through at least one of the one or more graphical user interfaces. A second input indicating that at least one application feature has been selected has been received. Determining, by at least one of the one or more processors, one or more settings in the selected at least one application feature. The one or more settings are associated with parameters that model one or more physical systems. Each box contains at least one of the one or more settings therein and is displayed via at least one of the one or more graphical user interfaces. At least one edit box is selected. Editing of one or more settings in the selected at least one edit box is received via one or more user input devices. The application model data structure is generated by the one or more processors as described above, including the received edits to the at least one or more settings of the at least one or more application features retrieved in the one or more application data structures.

It is contemplated that the above-described method for generating an application model data structure modeling a physical system may further include one or more of the following features in certain aspects. The method may further comprise the acts of: determining, by at least one of the one or more processors, a sequence of actions defined in the generated application model data structure, and executing, by at least one of the one or more processors, the sequence of actions. The method may also include a call action to the geometry subroutine as part of performing the geometry sequence action.

It is contemplated that the method for generating an application data structure, a modified application data structure, or an application model data structure, or the system for modifying an application data structure described above, may further include one or more of the following exemplary features: (i) the time-harmonic electromagnetic field frequency (input), the simulation (action), the application characteristics displaying the S-parameters (output), and the application data are set by running one of the models defined in the embedded model. (ii) Input for updating the reference pressure is received by running the acoustic simulation inline model, the simulation is run, and application features and application data for displaying the resulting wave propagation are displayed. (iii) The method includes receiving an inlet flow rate, running a fluid flow simulation, application features and application data showing an average flow rate at an outlet of a pipe in a tank fluid flow model defined for an inline model. (iv) Application characteristics and application data for a heat sink size (activation condition, output) that controls temperature under a given input value (input) at a given input load (input) are determined by executing an electronics model defined by a simulation (action) in-line model. (v) Values of the parameterized plasma reactor, updated geometry (actions, activation conditions), and application characteristics and application data for running simulations to determine the plating thickness of the semiconductor material of the wafer surface are received by executing the plasma reactor model defined in the built-in model.

Certain aspects of methods, systems, or apparatus are also contemplated herein, based on individual or collective steps, acts, features, and combinations of any two or more of the foregoing, disclosed, referenced, or otherwise indicated in this document.

It should be understood that the exemplary aspects for generating an application data structure, an application model data structure, interpreting an application model data structure, and generating a multi-physics model data structure as shown in fig. 16-43 are merely examples, and that these aspects may be used for a broader range of applications and physical phenomena, and are not limited to the application phenomena shown in the figures or described herein. For example, it should be understood that many different application data structures can be generated by the present invention. The illustrated aspects are merely examples of the broader operations that may be performed by an application developer system or module and a multi-physics modeling system. In addition, the interfaces shown are also representative of only a few of the interfaces that may be used in application developer modules and multi-physics modeling systems. Other graphical, user, or alternative input class interfaces are also contemplated.

Various alternatives to the above concepts are described in detail below in the order of letters a through Z, and various combinations and variations of these alternatives are expressly included.

Alternative A

One aspect of the invention is a system adapted to generate a custom application data structure for modeling a physical system. The system includes one or more processors, one or more user input devices, an optional display device, and one or more memory devices. In use, the one or more processors are adapted to embed a data structure of a predetermined or selected multiphysics model into an application data structure. The multi-physics model data structure contains a representation of one or more physical system models. Each physical system model represents a physical phenomenon and/or physical process. The multi-physics model data structure includes data representing at least one modeling operation for determining how to model or simulate one or more physical system models. Data representing one or more application features is added to the application data structure. Each application feature includes one or more primary data representing at least one form feature and/or secondary data representing at least one action feature. The form features include data specifying input data, and/or output data, and/or a representation format of the input and/or output data. The action features include data that specifies a sequence of operations to be performed when executing the application data structure. At least one sequence of operations to be performed includes at least one modeling operation. At least one sequence of operations to be performed includes an operation of providing data to generate at least one geometry of at least a portion of one or more models of physical systems. The customized application data structure is generated such that, when executing the data structure, customized modeling of the physical system is achieved using at least one of the at least one modeling operation, at least one geometry of at least a portion of the one or more physical system models, and the one or more application features.

Alternative B

One aspect of the invention is a system adapted to generate a custom application data structure for modeling a physical system. The system includes one or more processors, one or more user input devices, an optional display device, and one or more memory devices. In use, the one or more processors are adapted to embed a data structure of a predetermined or selected multiphysics model into an application data structure. The multi-physics model data structure contains a representation of one or more physical system models. Each physical system model represents a physical phenomenon and/or physical process. The multi-physics model data structure includes data representing at least one modeling operation for determining how to model or simulate one or more physical system models. When executed, data representing one or more application features is added to the application data structure to generate a customized application data structure. Each application feature includes one or more primary data representing at least one form feature and/or secondary data representing at least one action feature. The form features include data specifying input data, and/or output data, and/or a representation format of the input and/or output data. The action features include data that specifies a sequence of operations to be performed when executing the application data structure. At least one sequence of operations to be performed includes at least one modeling operation. At least one sequence of operations to be performed includes an operation of providing data to generate at least one geometry of at least a portion of one or more models of physical systems. The customized application data structure, when executed, provides customized modeling of the physical system using at least one of the at least one modeling operation, at least one geometry of at least a portion of the one or more physical system models, and one or more application characteristics.

Alternative C

One aspect of the invention is a system adapted to generate an application data structure modeling a physical system. The system includes one or more processors, one or more user input devices, an optional display device, and one or more memory devices. In use, the one or more processors are adapted to embed a data structure of a predetermined or selected multiphysics model in the application data structure. The multi-physics model data structure contains a representation of one or more physical system models. Each physical system model represents a physical phenomenon and/or physical process. The multi-physics model data structure includes data representing at least one modeling operation for determining how to model or simulate one or more physical system models. Data representing one or more application features is added to the application data structure. Each application feature includes one or more primary data representing at least one form feature and/or secondary data representing at least one action feature. The form features include data specifying input data, and/or output data, and/or a representation format of the input and/or output data. The action features include data that specifies a sequence of operations to be performed when executing the application data structure. At least one sequence of operations to be performed includes at least one modeling operation. At least one sequence of operations to be performed includes operations to provide data to generate at least one geometry for at least a portion of one or more models of physical systems. An application data structure is then generated that, when executed, provides customized modeling of the physical system using the at least one modeling operation, the at least one geometry of at least a portion of the one or more physical system models, and the at least one form feature.

Alternative D

A system according to either of alternatives a or B may include generating a customized application data structure using at least one form feature.

Alternative E

The system according to any one of the alternatives a to D may further include a system as follows: the latter is also adapted to be used to model or simulate one or more physical systems by executing an application data structure (e.g., a customized application data structure), displaying output data and/or receiving input data from a user in accordance with at least one form feature, and performing at least one modeling operation using at least one generated geometry.

Alternative F

According to any of alternatives a to E, the system may be further adapted to modify or update the application data structure according to one or more of: (i) displaying one or more pre-selected multi-physics model data structures to a user through a graphical user interface, and adding data representing the one or more user-selected and optionally user-modified multi-physics model data structures to an application data structure; (ii) displaying one or more pre-selected application features to a user via a graphical user interface, and adding data representing the one or more user-selected and optionally user-modified application features to an application data structure; (iii) the method includes displaying one or more pre-selected form features and/or one or more action features via a graphical user interface for at least one user-selected application feature, and adding data representing the user-selected and optionally user-modified one or more form features and/or action features to an application data structure.

Alternative G

According to any of alternatives a through F, the system may include one or more application features further including data representative of one or more of: (i) one or more input statements, each input statement for controlling parameter inputs that control setting of a physical component of at least one of the one or more physical system models; (ii) one or more activation conditions, each activation condition to specify one or more logical conditions for examining an input declaration value; (iii) one or more output claims, each output claim specifying a result to be displayed in accordance with a simulation of one or more physical system models; (iv) one or more input forms for controlling display and collection of revenue; (v) one or more output forms for controlling the display of the results declared in the output declaration.

Alternative H

The system according to any of alternatives a to G may comprise at least one form feature that, when executed, will enable receiving input from a user to modify and/or pre-select a sequence of operations.

Alternative scheme I

The system according to any of alternatives a to H may comprise at least one form feature which, when the application feature containing the form feature is executed, will activate receiving input from a user to modify and/or pre-select at least one geometry and/or at least one modeling operation.

Alternative J

A system according to any of alternatives a through I may include a geometry of at least one geometry, each geometry being zero-dimensional, one-dimensional, two-dimensional, or three-dimensional. The system according to any of alternatives a to I may also comprise a geometry of at least one geometry, each geometry being either zero-dimensional, two-dimensional, or three-dimensional.

Alternative K

The system according to any of alternatives a to J may comprise at least one modeling operation comprising one or more partial differential equations for solving a coupled system or representation.

Alternative L

The system according to any one of the alternative a to the alternative K may include: (i) application program characteristics including input statement, output statement, and action characteristics for setting the frequency of the harmonic electromagnetic field, running simulation, displaying S parameter; (ii) an embedded multi-physics model data structure for acoustic simulations, wherein application features include input statements, output statements, and action features to receive input for updating reference pressure, run the simulation, and display resulting wave propagation; (iii) an embedded multi-physics model data structure for tank fluid flow simulation, wherein the application features include an input statement, an output statement, and action features for receiving an inlet flow rate, performing the fluid flow simulation, and displaying an average flow rate at the outlet of the pipeline; (iv) an embedded multi-physics model data structure for an electronic device, wherein application features include input statements, output statements, form features, activation conditions, and action features to determine a size of a heat sink to control temperature below a given input value under a given input load; and/or (v) application features including input statements, output statements, form characteristics, activation conditions, and action characteristics to receive values for the parameterized plasma reactor, update geometry, and run simulations to determine plating thickness of semiconductor material on the wafer surface.

Alternative M

The system according to any of alternatives a to L may include an application data structure that is an initial application data structure used to generate the customized application data structure. The initial application data structure includes at least one previously embedded application feature and/or at least one previously embedded multi-physics model data structure.

Alternative N

Another aspect of the invention is a method of generating an application data structure for modeling a physical system. The method includes embedding a data structure of a predefined or selected multi-physics model into an application data structure. The multi-physics model data structure contains a representation of one or more physical system models. Each physical system model represents a physical phenomenon and/or physical process. The multi-physics model data structure includes data representing at least one modeling operation for determining how to model or simulate one or more physical system models. Data representing one or more application features is added to the application data structure. Each application feature includes one or more primary data representing at least one form feature and/or secondary data representing at least one action feature. The form features include data specifying input data, and/or output data, and/or a representation format of the input and/or output data. The action features include data that specifies a sequence of operations to be performed when executing the application data structure. At least one sequence of operations to be performed includes at least one modeling operation. At least one sequence of operations to be performed includes operations to provide data to generate at least one geometry for at least a portion of one or more models of physical systems. An application data structure is generated that, when executed, provides customized modeling of the physical system using at least one modeling operation as described herein, at least one geometry of at least a portion of one or more models of the physical system, and at least one form feature.

Alternative O

Another aspect of the invention is a method of generating a custom application data structure for modeling a physical system. The method includes embedding a data structure of a predefined or selected multi-physics model into an application data structure. The multi-physics model data structure contains a representation of one or more physical system models. Each physical system model represents a physical phenomenon and/or physical process. The multi-physics model data structure includes data representing at least one modeling operation for determining how to model or simulate one or more physical system models. Data representing one or more application features is added to the application data structure. Each application feature includes one or more primary data representing at least one form feature and/or secondary data representing at least one action feature. The form features include data specifying input data, and/or output data, and/or a representation format of the input and/or output data. The action features include data that specifies a sequence of operations to be performed when executing the application data structure. At least one sequence of operations to be performed includes at least one modeling operation. At least one sequence of operations to be performed includes operations to provide data to generate at least one geometry for at least a portion of one or more models of physical systems. The custom application data structure is then generated by the embed and add operations. When the customized application data structure is executed, customized modeling of the physical system may be provided using at least one of at least one modeling operation, at least one geometry of at least a portion of the one or more physical system models, and one or more application features.

Alternative P

Another aspect of the invention is a method of generating a custom application data structure for modeling a physical system. The method includes embedding a data structure of a predefined or selected multi-physics model into an application data structure. The multi-physics model data structure contains a representation of one or more physical system models. Each physical system model represents a physical phenomenon and/or physical process. The multi-physics model data structure includes data representing at least one modeling operation for determining how to model or simulate one or more physical system models. Data representing one or more application features is added to an application data structure by at least one of the one or more processors and/or one or more input devices. Each application feature includes one or more primary data representing at least one form feature and/or secondary data representing at least one action feature. The form features include data specifying input data, and/or output data, and/or a representation format of the input and/or output data. The action features include data that specifies a sequence of operations to be performed when executing the application data structure. At least one sequence of operations to be performed includes at least one modeling operation. At least one sequence of operations to be performed includes an operation of providing data to generate at least one geometry of at least a portion of one or more models of physical systems. The application data structure is generated by at least one of the one or more processors and, when executed, provides customized modeling of the physical system using at least one of at least one modeling operation, at least one geometry of at least a portion of the one or more modeled physical systems, and at least one of the one or more application features.

Alternative Q

Another aspect of the invention is a method of generating a custom application data structure for modeling a physical system. The method includes embedding a data structure of a predetermined or selected multi-physics model into an application data structure. The multi-physics model data structure contains a representation of one or more physical system models. Each physical system model represents a physical phenomenon and/or physical process. The multi-physics model data structure includes data representing at least one modeling operation for determining how to model or simulate one or more physical system models. Data representing one or more application features is added to the application data structure to generate a customized application data structure. Each application feature includes one or more primary data representing at least one form feature and/or secondary data representing at least one action feature. The form features include data specifying input data, and/or output data, and/or a representation format of the input and/or output data. The action features include data that specifies a sequence of operations to be performed when executing the application data structure. At least one sequence of operations to be performed includes at least one modeling operation. At least one sequence of operations to be performed includes operations to provide data to generate at least one geometry for at least a portion of one or more models of physical systems. When the customized application data structure is executed, customized modeling of the physical system is provided using at least one of at least one modeling operation, at least one geometry of at least a portion of the one or more physical system models, and one or more application features.

Alternative scheme R

The method according to any of alternative O through alternative Q includes generating a custom application data structure using at least one expression feature.

Alternative S

The method according to any of alternatives N through R may include modeling or simulating one or more physical systems by executing the custom application data structure, displaying output data and/or receiving user input data in accordance with at least one form feature, and performing at least one modeling operation using at least one generated geometry.

Alternative T

The method according to any of alternative N to alternative S may further be adapted to be used to modify or update the application data structure according to one or more of the following: (i) displaying one or more pre-selected multi-physics model data structures to a user through a graphical user interface, and adding data representing the one or more user-selected and optionally user-modified multi-physics model data structures to an application data structure; (ii) displaying one or more pre-selected application features to a user via a graphical user interface, and adding data representing the one or more user-selected and optionally user-modified application features to an application data structure; (iii) the method includes displaying one or more pre-selected form features and/or one or more action features via a graphical user interface for at least one user-selected application feature, and adding data representing the user-selected and optionally user-modified one or more form features and/or action features to an application data structure.

Alternative U

The method according to any of alternatives N to T may comprise at least one form feature which, when the application feature containing the form feature is executed, will activate receiving input from a user to modify the input and/or the pre-selection operation sequence.

Alternative V

The method according to any of the alternatives N to U may comprise at least one form feature which, when executed, will activate receiving input from a user to modify and/or pre-select at least one geometry and/or at least one modeling operation.

Alternative W

The method according to any of alternative N to alternative V may comprise a geometry of at least one geometry, each geometry being one of zero, one, two, or three dimensional. The method according to any of alternative N to alternative V may also comprise a geometry of at least one geometry, each geometry being one of zero-dimensional, two-dimensional, or three-dimensional.

Alternative X

The method according to any of alternative N to alternative W may comprise at least one modeling operation comprising one or more partial differential equations for solving a coupled system or representation.

Alternative Y

The method according to any one of alternative N to alternative X may comprise: (i) application program characteristics including input statement, output statement, and action characteristics for setting the frequency of the harmonic electromagnetic field, running simulation, displaying S parameter; (ii) an embedded multi-physics model data structure for acoustic simulations, wherein application features include input statements, output statements, and action features to receive input for updating reference pressure, run the simulation, and display resulting wave propagation; (iii) an embedded multi-physics model data structure for tank fluid flow simulation, wherein the application features include an input statement, an output statement, and action features for receiving an inlet flow rate, performing the fluid flow simulation, and displaying an average flow rate at the outlet of the pipeline; (iv) an embedded multi-physics model data structure for an electronic device, wherein application features include input statements, output statements, form features, activation conditions, and action features to determine a heat sink size to control temperature below a given input value at a given input load; (v) including input statements, output statements, form features, activation conditions, and application features to receive values for a parameterized plasma reactor, update geometry, and run simulations to determine plating thickness of semiconductor material on a wafer surface.

Alternative Z

The method according to any of alternative N through alternative Y may include the application data structure being an initial application data structure used to generate the customized application data structure. The initial application data structure includes at least one previously embedded application feature and/or at least one previously embedded multi-physics model data structure.

Alternative AA

Use of a custom application data structure generated or modified according to the method described in alternatives a to M or N to Z for modeling a physical system, which custom application data structure may comprise one or more processors, one or more user input devices, an optional display device, and one or more storage devices when used by a user in a system according to any one of alternatives a to M or another system.

Alternative AB

For a customized application data structure for a modeled physical system stored in a physical medium or system comprising one or more processors and one or more storage devices, a customized application data structure generated or modified in accordance with the system of any of alternatives a through M and/or any of the methods of alternatives N through Z may be included.

It is further contemplated that the one or more application data structures described in one or more of alternatives a through AB may include one or more custom application data structures that have been previously created that are stored and retrieved. For example, previous custom application data structures may be retrieved and embedded in memory, which may be further customized and/or modified to create an updated and/or modified application data structure that includes different application features and/or multiple physics model data structures.

Additional aspects of the above concepts may be further illustrated by various additional ones of alternatives AA1 through AA47, detailed below, and can include various combinations and subcombinations of these alternatives.

Alternative AA1

In accordance with another aspect of the invention, a method is performed in a computer system for generating an application data structure in a graphical user interface. The method includes the step of embedding a multiphysics model data structure into an application data structure. One or more application features are added to the application data structure. At least one form feature is added to the application feature. At least one action feature is added to the application feature. The action features are linked to at least one operation defined in the embedded multi-physics model data structure.

Alternative AA2

The method according to alternative AA1 can further comprise an application data structure in the application tree structure.

Alternative AA3

The method according to any of the alternatives AA 1-AA 2 can further comprise adding geometric subroutines to the embedded multiphysics model data structure and adding geometric subroutine call features to the embedded multiphysics model data structure.

Alternative AA4

The method according to any of the alternatives AA 1-AA 3 can further comprise receiving an input selection in the geometric subroutine for a set of geometric operations in the multi-physics model data structure embedded. An output selection is generated in the geometric subroutine in the built-in multiphysics model data structure. Contributions are used to generate cumulative selections in the embedded multi-physics model data structure.

Alternative AA5

The method according to any of the alternatives AA 1-AA 4 can further comprise receiving a location and orientation that matches a working plane of the geometric subroutine in the multi-physics model data structure embedded for a set of geometric operations. Generating a position and orientation for matching a work plane in the geometric subroutine in the embedded multi-physics model data structure.

Alternative AA6

The method according to any of the alternatives AA 1-AA 5 can further comprise causing the geometric subroutine call to an external multi-physical field model data structure linked into the embedded multi-physical field model data structure.

Alternative AA7

The method according to any of the alternatives AA 1-AA 6 can further comprise a geometric invocation of an if, else-if or else statement in the multi-physics model data structure embedded.

Alternative AA8

In accordance with another aspect of the invention, a method is performed in a computer system for generating an application data structure in a graphical user interface. The method includes the steps of determining and displaying a set of applications defined in a set of application data structures. At least one application is selected. Application characteristics are determined and displayed for the selected application defined in the application data structure. Then, an application feature is selected. Settings for selected application features defined in the application data structure are determined and displayed. Then, the settings of the selected application features are edited.

Alternative AA9

The method according to alternative AA8 can further comprise selecting application features for invoking geometric operations of the geometric subroutine and adding the geometric operations to the application model data structure.

Alternative AA10

The method according to any of the alternatives AA 8-AA 9 can further comprise adding the output selection into an application model data structure and adding the contribution to an accumulated selection in the application model data structure.

Alternative AA11

In accordance with another aspect of the invention, a method is performed in a computer system for generating an application model data structure. The method includes determining an application model defined in an application model data structure. At least one application model data structure is loaded. A sequence of actions defined in one or more application model data structures is processed and the sequence of actions is performed.

Alternative AA12

The method according to alternative AA11 can further comprise processing a geometric sequence comprising a geometric subroutine call and performing a geometric sequence action.

Alternative AA13

In accordance with another aspect of the invention, a system is adapted for use in generating a custom application data structure for modeling a physical system. The system includes one or more processors, one or more user input devices, an optional display device, and one or more memory devices. In use, the one or more processors are adapted to embed a data structure of a predetermined or selected multi-physics model into an application data structure. The multi-physics model data structure contains a representation of one or more physical system models. Each physical system model represents a physical phenomenon and/or physical process. The multi-physics model data structure contains data representing at least one modeling operation for determining how to model or simulate one or more physical system models. Geometric data representing one or more geometric subroutines is added to the embedded multi-physics model data structure. The added geometric data includes parameter definitions for one or more physical system models. Call data representing one or more geometric subroutine calls to execute at least one of the one or more geometric subroutines is added to the embedded multi-physical field model data structure. Application data representing one or more application features is added to the application data structure. Each application feature includes one or more primary data representing at least one form feature and/or secondary data representing at least one action feature. The form features include data specifying input data, and/or output data, and/or a representation format of the input and/or output data. The action features include data that specifies a sequence of operations to be performed when executing the application data structure. At least one sequence of operations to be performed includes at least one modeling operation. At least one sequence of operations to be performed includes an operation of providing data to generate at least one geometry of at least a portion of one or more models of physical systems. The customized application data structure is generated such that, when executing the data structure, customized modeling of the physical system is achieved using the at least one modeling operation, at least one geometry of at least a portion of the one or more physical system models, at least one application feature of the one or more application features (e.g., including at least one form feature), and at least one geometry subroutine of the one or more geometry subroutines.

Alternative AA14

The method according to alternative AA13 can further comprise geometric data representing the one or more geometric subroutines and comprising argument data for at least a part of the parameter definition. The argument data includes parameters used to control geometric operations in geometric modeling operations associated with one or more physical system models and geometric dimensions of objects.

Alternative AA15

The method according to any of the alternatives AA 13-AA 14 can further comprise geometry data representing the one or more geometry subroutines and comprising instruction data to generate an output selection referencing at least one modeling operation in the embedded multiphysics model data structure.

Alternative AA16

The method according to any of the alternatives AA13 to AA15 can further comprise generating the customized application data structure using at least one form feature.

Alternative AA17

The method according to any of the alternatives AA 13-AA 16 can further comprise the system being further adapted to model or simulate one or more physical systems by executing the customized application data structure, displaying output data and/or receiving user input data in accordance with at least one form feature, and performing at least one modeling operation using at least one generated geometry resulting from executing at least one of the one or more geometric subroutines.

Alternative AA18

The method according to any of the alternatives AA13 to AA17 can further comprise the system being further adapted to modify or update the application data structure according to one or more of: (i) displaying one or more pre-selected multi-physics model data structures to a user through a graphical user interface, and adding data representing the one or more user-selected and optionally user-modified multi-physics model data structures to an application data structure; (ii) displaying one or more pre-selected application features to a user via a graphical user interface, and adding data representing the one or more user-selected and optionally user-modified application features to an application data structure; (iii) the method includes displaying one or more pre-selected form features and/or one or more action features via a graphical user interface for at least one user-selected application feature, and adding data representing the user-selected and optionally user-modified one or more form features and/or action features to an application data structure.

Alternative AA19

The method according to any of the alternatives AA 13-AA 18 can further comprise that at least one form feature will activate receiving user input when executing an application comprising the form feature in order to modify and/or pre-select at least one geometry and/or at least one modeling operation.

Alternative AA20

The method according to any of the alternatives AA13 to AA19 can further comprise the application data structure being an initial application data structure used to generate the customized application data structure. The initial application data structure includes at least one previously embedded application data structure and/or at least one previously embedded multi-physics model data structure.

Alternative AA21

In accordance with another aspect of the invention, a method generates a custom application data structure for modeling a physical system. The method includes embedding a data structure of a predetermined or selected multiphysics model into an application data structure. The multi-physics model data structure contains a representation of one or more physical system models. Each physical system model represents a physical phenomenon and/or physical process. The multi-physics model data structure contains data representing at least one modeling operation for determining how to model or simulate one or more physical system models. Geometric data representing one or more geometric subroutines is added to the embedded multi-physics model data structure. The added geometric data includes parameter definitions for one or more physical system models. Call data representing one or more geometric subroutine calls to execute at least one of the one or more geometric subroutines is added to the embedded multi-physical field model data structure. Application data representing one or more application features is added to the application data structure. Each application feature includes one or more primary data representing at least one form feature and/or secondary data representing at least one action feature. The form features include data specifying input data, and/or output data, and/or a representation format of the input and/or output data. The action features include data that specifies a sequence of operations to be performed when executing the application data structure. At least one sequence of operations to be performed includes at least one modeling operation. At least one sequence of operations to be performed includes an operation of providing data to generate at least one geometry of at least a portion of one or more models of physical systems. Through the embedding and adding operations, the customized application data structure is generated. When executing this data structure, customized modeling of the physical system is achieved by using the at least one modeling operation, at least one geometry of at least a portion of the one or more physical system models, and at least one of the one or more application features (e.g., including at least one form feature).

Alternative AA22

The method according to alternative AA21 can further comprise geometric data representing the one or more geometric subroutines and comprising argument data for at least a part of the parameter definition. The argument data includes parameters used to control geometric operations in geometric modeling operations associated with one or more physical system models and geometric dimensions of objects.

Alternative AA23

The method according to any of the alternatives AA 21-AA 22 can further comprise geometry data representing the one or more geometry subroutines and comprising instruction data to generate an output selection referencing at least one modeling operation in the embedded multiphysics model data structure.

Alternative AA24

The method according to any of the alternatives AA21 to AA23 can further comprise receiving input selection data for the one or more geometric subroutines. The input selection data includes geometric manipulation data for the embedded multi-physics model data structure. Output selection data is generated from geometry data for the geometric entity in the embedded multi-physics model data structure. Contribution data is generated for accumulated geometric entity selection in an embedded multi-physics model data structure. The contribution data is associated with a selection of geometric entities for a modeling operation in one or more physical system models.

Alternative AA25

The method according to any of the alternatives AA21 to AA24 can further comprise receiving first position and orientation data for matching end planes of existing work planes defined in the geometric sequence of geometric subroutines in the embedded multi-physics model data structure. Second position and orientation data is generated for a start plane that matches an end plane of an existing work plane. The generated second position and orientation data is accessible in a geometric sequence of geometric subroutines in the embedded multi-physics model data structure.

Alternative AA26

The method according to any of the alternatives AA21 to AA25 can further comprise linking call data representing at least one of the one or more geometric subroutine calls to a second external multi-physical field model data structure of the embedded multi-physical field model data structures.

Alternative AA27

The method according to any of the alternatives AA21 to AA26 can further comprise calling data representing at least one geometric subroutine call and comprising a representation of an if, else-if or else statement in an embedded multi-physical field model data structure.

Alternative AA28

The method according to any of the alternatives AA21 to AA27 can further comprise modeling or simulating one or more physical systems by executing the custom application data structure, displaying output data and/or receiving user input data in accordance with at least one form feature, and performing at least one modeling operation using at least one generated geometry.

Alternative AA29

The method according to any of the alternatives AA21 to AA28 can further comprise a method further adapted to modify or update the application data structure according to one or more of the following: (i) displaying one or more pre-selected multi-physics model data structures to a user through a graphical user interface, and adding data representing the one or more user-selected and optionally user-modified multi-physics model data structures to an application data structure; (ii) displaying one or more pre-selected application features to a user via a graphical user interface, and adding data representing the one or more user-selected and optionally user-modified application features to an application data structure; (iii) the method includes displaying one or more pre-selected form features and/or one or more action features via a graphical user interface for at least one user-selected application feature, and adding data representing the user-selected and optionally user-modified one or more form features and/or action features to an application data structure.

Alternative AA30

The method according to any of the alternatives AA 21-AA 30 can further comprise that at least one form feature will activate receiving user input when executing an application comprising the form feature in order to modify and/or pre-select at least one geometry and/or at least one modeling operation.

Alternative AA31

The method according to any of the alternatives AA21 to AA31 can further comprise an application data structure being an initial application data structure used to generate the customized application data structure. The initial application data structure includes at least one previously embedded application data structure and/or at least one previously embedded multi-physics model data structure.

Alternative AA32

In accordance with another aspect of the invention, an apparatus for generating an application data structure includes a physical computing system including one or more processing elements, one or more user input devices, a display device, and one or more storage devices. At least one of the one or more storage devices includes executable instructions for generating an application data structure. The executable instructions cause at least one of the one or more processing sections to embed, by execution, a multi-physics model data structure of the physical system in the application data structure. The embedded multi-physics model data structure includes at least one modeling operation of a physical system. One or more geometric subroutines are added to the embedded multiphysics model data structure through at least one of the one or more input devices. At least one of the one or more geometric subroutines includes a parameter definition associated with a physical system. One or more calling features are added to the embedded multi-physics model data structure through at least one of the one or more input devices. The calling feature allows execution of the geometry subroutine. Determining, by at least one of the one or more processing portions, one or more application features to be added to the application data structure. The one or more application features are associated with a physical system model. Adding, via at least one of the one or more input devices, primary data representing at least one form feature for at least one of the one or more application features of the physical system model. Adding, via at least one of the one or more input devices, secondary data representing at least one action characteristic for at least one of the one or more application characteristics of the physical system model. Secondary data representative of the at least one action feature is associated with the at least one modeling operation for the physical system to define a sequence of operations that model the physical system.

Alternative AA33

The apparatus according to alternative AA32 can further include at least one of the one or more storage devices including executable instructions to generate the application data structure. The executable instructions cause at least one of the one or more processing portions to, by execution, further perform actions comprising updating an application data structure, the updated application data structure comprising the added primary data, the added secondary data, the defined sequence of operations, the one or more geometric subroutines, and the one or more calling features. The updated application data structure is stored in at least one of the one or more storage devices.

Alternative AA34

The apparatus according to any of the alternatives AA32 to AA33 can further comprise one or more geometric subroutines comprising arguments for at least a part of the parameter definition. The arguments control geometric operations in geometric modeling operations associated with the physical system and geometric dimensions of the objects.

Alternative AA35

An apparatus according to any of the alternatives AA 32-AA 34 can further comprise one or more geometric subroutines comprising output selections that reference modeling operations in the embedded multiphysics model data structure.

Alternative AA36

According to yet another aspect of the invention, a method performed in a computer system having one or more physical computing devices is configured to generate a modified application data structure to model a physical system. The method includes embedding, by one or more physical computing devices, a multi-physical field model data structure into an application data structure stored in one or more storage devices. The embedded multi-physics model data structure includes at least one multi-physics modeling operation that is specific to the physical system being modeled. One or more geometric subroutines are added to the embedded multiphysics model data structure via one or more input devices. At least one of the one or more geometric subroutines includes a parameter definition associated with a physical system. One or more geometric subroutine calls are added to the embedded multiphysics model data structure through at least one of the one or more input devices. The one or more geometric subroutine calls allow each geometric subroutine to be executed. Determining, by at least one of the one or more physical computing devices, one or more application features to be added to an application data structure. The one or more application features are associated with a physical system. Obtaining, by at least one of the one or more physical computing devices, application data representative of the one or more determined application characteristics. The application data includes form data representing at least one form characteristic of the modeled physical system and action data representing at least one action characteristic. The motion data representing the at least one motion feature is associated with the at least one modeling operation for the physical system defined in the embedded multi-physics model data structure. The association between the action data and the at least one modeling operation defines a sequence of operations for modeling the physical system.

Alternative AA37

The method according to alternative AA36 can further include an act of forming a modified application data structure that includes the obtained application data, the one or more geometric subroutines, and the one or more calling features. The modified application data structure is stored in at least one of the one or more storage devices.

Alternative AA38

The method according to any of the alternatives AA36 to AA37 can further comprise receiving, by at least one of the one or more input devices, one or more input selections comprising geometric entities for the geometric sub-routine. At least one of the input selections is associated with a set of geometric operations for the embedded multi-physics model data structure. One or more geometric entity output selections are generated in an embedded multi-physical field model data structure by at least one of the one or more physical computing devices executing the geometric subroutine. The contributions are used to generate an accumulated geometric entity selection in an embedded multi-physics model data structure associated with a geometric entity selection for a modeling operation in a physical system model.

Alternative AA39

The method according to any of the alternatives AA36 to AA38 can further comprise receiving first position and orientation data of a previous end plane, the first position and orientation data being used to match the previous end plane to an existing work plane defined in a geometric sequence of geometric subroutines in the embedded multi-physics model data structure. In order to match the previous end plane with the new working plane, second position and orientation data is generated. The generated second position and orientation data is accessible in a geometric sequence of geometric subroutines in the embedded multi-physics model data structure.

Alternative AA40

The method according to any of the alternatives AA36 to AA39 can further comprise causing at least one of the one or more geometric subroutine calls to link to a second external multi-physical field model data structure in the embedded multi-physical field model data structure.

Alternative AA41

The method according to any of the alternatives AA36 to AA40 can further comprise that the if, else-if and/or else statement in the embedded multi-physics model data structure contains at least one of the one or more geometric subroutine calls.

Alternative AA42

According to another aspect of the invention, a method performed in a computer system includes one or more processing sections configured to generate an application model data structure that models a physical system. The method includes determining, by one or more processing portions, a plurality of actions for modeling one or more physical system applications. The plurality of applications is determined by application data stored in one or more application data structures. Displaying a list of the plurality of applications in one or more graphical user interfaces. A first input is received indicating a first selection of at least one of the plurality of applications. For the selected at least one of the plurality of applications, one or more application characteristics are determined by at least one of the one or more processing portions. At least one of the one or more application features includes a geometric operation represented as application data defined or retrieved in at least one of the one or more application data structures. Displaying the determined application feature in at least one of the one or more graphical user interfaces. A second input is received indicating a second selection of at least one application feature. The second selection includes an application feature for invoking a geometric operation of the geometric subroutine. Determining, by at least one of the one or more processing portions, one or more settings of the selected at least one application feature. The one or more settings are associated with parameters that model one or more physical systems. Each edit box includes at least one of the one or more settings and is displayed through at least one of the one or more graphical user interfaces. At least one edit box is selected. Editing of the one or more settings included in the selected at least one edit box is received via one or more user input devices.

Alternative AA43

The method according to alternative AA42 can further include generating, by at least one of the one or more processing portions, an application model data structure including received edits to the at least one or more settings of the at least one or more application features retrieved from the one or more application data structures.

Alternative AA44

The method according to any of the alternatives AA 42-AA 43 can further include determining, by at least one of the one or more processors, a sequence of actions defined in the generated application model data structure. Executing, by at least one of the one or more processing portions, the sequence of actions.

Alternative AA45

The method according to any of the alternatives AA42 to AA44 can further comprise an act of calling a geometric subroutine as part of performing the geometric sequence action.

Alternative AA46

The method according to any of the alternatives AA42 to AA45 can further comprise receiving, by at least one of the one or more input devices, an input selection comprising a geometric entity for the geometric subroutine. At least one input selection is associated with a set of geometric operations for the embedded multi-physics model data structure. One or more geometric entity output selections in the embedded multi-physics model data structure are generated by at least one of the one or more processing portions executing the geometric subroutines. The contributions are used to generate an accumulated geometric entity selection in an embedded multi-physics model data structure associated with a geometric entity selection for a modeling operation in a physical system model.

Alternative AA47

For customized application data structures stored on physical media or in a system comprising one or more processors and one or more storage devices for modeling a physical system, generating and/or modifying the customized application data structures can include a system according to any of the alternatives AA13 to AA19, a method according to any of the alternatives AA21 to AA31 and AA36 to AA46, and/or an apparatus according to any of the alternatives AA32 to AA 35.

Each and every aspect and obvious variation of the above description is considered to fall within the spirit and scope of the claimed invention, and is set forth in the following claims.

In the claims, any reference signs placed between parentheses shall not be construed as limiting the claim. The word "comprising" does not exclude the presence of elements or steps other than those listed in a claim. The word "a" or "an" preceding an element does not exclude the presence of a plurality of such elements.

The mere fact that certain measures are recited in mutually different dependent claims does not indicate that a combination of these measures cannot be used to advantage.

Claims (38)

1. A system adapted to generate a custom application data structure for modeling a physical system, the system comprising: one or more processors, one or more user input devices, and one or more storage devices,

wherein the one or more processors are adapted, in use, to:

embedding a predetermined or selected multi-physical field model data structure into an application data structure, wherein the multi-physical field model data structure contains a representation of one or more physical system models, each of which represents a physical phenomenon and/or physical process, wherein the multi-physical field model data structure contains data representing at least one modeling operation for determining how to model or simulate the one or more physical system models;

adding geometric data representing one or more geometric subroutines to the embedded multi-physics model data structure, the added geometric data including parameter definitions of the one or more physical system models;

adding call data to the built-in multi-physics model data structure, the call data representing one or more geometric subroutine calls to execute at least one of the one or more geometric subroutines; and

adding application data representing one or more application features to the application data structure, where each of the application features includes one or more of (i) primary data representing at least one form feature and/or (ii) secondary data representing at least one action feature,

wherein the form characteristics comprise data specifying input data, and/or output data, and/or a representation format of the input and/or output data, the action characteristics comprise data specifying a sequence of operations to be performed when executing the application data structure, and

wherein at least one operation of the sequence of operations to be performed comprises the at least one modeling operation and at least one operation of the sequence of operations to be performed comprises an operation of providing data for generating at least one geometry of at least a portion of the one or more physical system models,

a custom application data structure is thus generated that, when executed, provides customized modeling of the physical system as follows: the modeling uses the at least one modeling operation, the at least one geometry of at least a portion of the one or more physical system models, at least one of the one or more application features, and at least one of the one or more geometric subroutines.

2. The system of claim 1, further comprising a display device.

3. The system of claim 1, wherein the geometric data representative of the one or more geometric subroutines comprises argument data for at least a portion of the parameter definition, the argument data comprising parameters of: these parameters are used to control geometric operations in geometric modeling operations associated with the one or more physical system models and geometric dimensions of objects.

4. The system of claim 2, wherein the geometric data representative of the one or more geometric subroutines comprises argument data for at least a portion of the parameter definition, the argument data comprising parameters of: these parameters are used to control geometric operations in geometric modeling operations associated with the one or more physical system models and geometric dimensions of objects.

5. The system of any of claims 1 to 4, wherein the geometric data representative of the one or more geometric subroutines comprises instruction data to generate an output selection of: the output selection references the at least one modeling operation in the multi-physics model data structure that is embedded.

6. The system of any of claims 1 to 4, wherein the custom application data structure is generated using at least one form feature.

7. The system of any one of claims 1 to 4, wherein the system is further adapted to model or simulate one or more physical systems by executing the custom application data structure, displaying output data and/or receiving user input data in accordance with at least one form feature, and performing the at least one modeling operation using at least one generated geometry resulting from execution of at least one of the one or more geometric subroutines.

8. The system of any one of claims 1 to 4, further adapted to modify or update the application data structure in accordance with one or more of the following:

displaying one or more pre-selected multi-physical field model data structures to a user via a graphical user interface and adding data representing the one or more user-selected multi-physical field model data structures to the application data structure;

displaying one or more pre-selected application features to a user via a graphical user interface and adding data representing the one or more user-selected application features to the application data structure; and

one or more pre-selected form features and/or one or more action features are displayed via a graphical user interface for at least one user-selected application feature, and data representing the one or more user-selected form features and/or action features is added to the application data structure.

9. The system of claim 8, wherein at least one of the user-selected multiphysics model data structure, the user-selected application feature, and the user-selected form feature and/or action feature is user-selected and user-modified.

10. The system of any of claims 1 to 4, wherein there is at least one form feature that, when the application feature containing the form feature is executed, enables input from a user to modify and/or pre-select the at least one geometry and/or the at least one modeling operation.

11. The system of any of claims 1-4, wherein the application data structure is an initial application data structure used in generating the customized application data structure, the initial application data structure comprising at least one previously embedded application feature and/or at least one previously embedded multi-physics model data structure.

12. A method of generating a custom application data structure for modeling a physical system, the method comprising:

embedding a predetermined or selected multi-physical field model data structure into an application data structure, wherein the multi-physical field model data structure contains a representation of one or more physical system models, each of which represents a physical phenomenon and/or physical process, wherein the multi-physical field model data structure contains data representing at least one modeling operation for determining how to model or simulate the one or more physical system models;

adding geometric data representing one or more geometric subroutines to the embedded multi-physics model data structure, the geometric data including parameter definitions of the one or more physical system models;

adding call data to the built-in multi-physics model data structure, the call data representing one or more geometric subroutine calls to execute at least one of the one or more geometric subroutines;

adding data representing one or more application features to the application data structure, where each of the application features includes one or more of (i) primary data representing at least one form feature and/or (ii) secondary data representing at least one action feature,

wherein the form characteristics comprise data specifying input data, and/or output data, and/or a representation format of the input and/or output data, and the action characteristics comprise data specifying a sequence of operations to be performed when executing the application data structure, and

wherein at least one operation of the sequence of operations to be performed comprises the at least one modeling operation and at least one operation of the sequence of operations to be performed comprises an operation of providing data for generating at least one geometry of at least a portion of the one or more physical system models; and

generating a custom application data structure from the inline and add-on operations, the custom application data structure when executed providing a custom physical system modeling as follows: the modeling uses the at least one modeling operation, the at least one geometry of at least a portion of the one or more physical system models, and at least one of the one or more application features.

13. The method of claim 12, wherein the geometric data representing the one or more geometric subroutines comprises argument data for at least a portion of the parameter definition, the argument data comprising parameters of: these parameters are used to control geometric operations in geometric modeling operations associated with the one or more physical system models and geometric dimensions of objects.

14. The method of claim 12 or 13, wherein the geometric data representative of the one or more geometric subroutines comprises instruction data to generate an output selection of: the output selection references the at least one modeling operation in the multi-physics model data structure that is embedded.

15. The method of claim 12 or 13, further comprising:

receiving input selection data for the one or more geometric subroutines, the input selection data including geometric operation data for the embedded multi-physics model data structure;

generating output selection data for geometric entities in the embedded multi-physics model data structure from the geometric data; and

generating contribution data for accumulated geometric entity selections in the embedded multi-physical field model data structure, the contribution data associated with geometric entity selections for modeling operations in the one or more physical system models.

16. The method of claim 12 or 13, further comprising:

receiving first position and orientation data to match an end plane of an existing work plane defined in a geometric sequence of the geometric subroutine in the multi-physics model data structure as embedded; and

generating second position and orientation data for a start plane that matches the end plane of the existing work plane, the generated second position and orientation data being accessible in the geometric sequence of the geometric subroutine in the multi-physics model data structure that is embedded.

17. The method of claim 12 or 13, further comprising: linking the call data representing at least one of the one or more geometric subroutine calls to a second external one of the multi-physical field model data structures embedded.

18. The method of claim 12 or 13, wherein the call data representing at least one of the one or more geometric subroutine calls comprises a representation of an if, else-if and/or else statement in the embedded multi-physics model data structure.

19. The method according to claim 12 or 13, the method comprising: modeling or simulating one or more physical systems by executing the custom application data structure, displaying output data and/or receiving user input data in accordance with at least one form feature, and performing the at least one modeling operation using at least one generated geometry.

20. A method according to claim 12 or 13, wherein the method is further adapted to modify or update the application data structure in accordance with one or more of the following:

displaying one or more pre-selected multi-physical field model data structures to a user via a graphical user interface and adding data representing the one or more user-selected multi-physical field model data structures to the application data structure;

displaying one or more pre-selected application features to a user via a graphical user interface and adding data representing the one or more user-selected application features to the application data structure;

one or more pre-selected form features and/or one or more action features are displayed via a graphical user interface for at least one user-selected application feature, and data representing the one or more user-selected form features and/or action features is added to the application data structure.

21. The method of claim 20, wherein at least one of the user-selected multiphysics model data structure, the user-selected application feature, and the user-selected form feature and/or action feature is user-selected and user-modified.

22. The method of claim 12 or 13, wherein there is at least one form feature that, when executed, enables input from a user to modify and/or pre-select the at least one geometry and/or the at least one modeling operation to be received.

23. The method of claim 12 or 13, wherein the application data structure is an initial application data structure used in generating the customized application data structure, the initial application data structure comprising at least one previously embedded application feature and/or at least one previously embedded multi-physics model data structure.

24. An apparatus for generating an application data structure, the apparatus comprising a physical computing system including: one or more processing portions, one or more user input devices, a display device, and one or more memory devices,

at least one of the one or more storage devices includes executable instructions to generate an application data structure, which when executed, cause at least one of the one or more processing portions to perform the following acts:

embedding a multi-physics model data structure of a physical system into an application data structure, the embedded multi-physics model data structure including at least one modeling operation for the physical system;

adding, by at least one of the one or more input devices, one or more geometric subroutines to the embedded multi-physical field model data structure, at least one of the one or more geometric subroutines including a parameter definition associated with the physical system;

adding, via at least one of the one or more input devices, one or more calling features to the embedded multi-physics model data structure, the calling features causing the geometric sub-routine to be executed;

determining, by at least one of the one or more processing portions, one or more application features to be added to the application data structure, the one or more application features associated with a model of the physical system;

adding, by at least one of the one or more input devices, primary data representing at least one form feature for at least one of the one or more application features of the model of the physical system;

adding, by at least one of the one or more input devices, secondary data representing at least one action feature for at least one of the one or more application features of the model of the physical system; and

associating the secondary data representative of the at least one action feature with the at least one modeling operation for the physical system to define a sequence of operations for modeling the physical system.

25. The apparatus of claim 24, wherein at least one of the one or more storage devices comprises executable instructions to generate an application data structure, which when executed, cause at least one of the one or more processing portions to perform further actions comprising updating the application data structure, the updated application data structure comprising the added primary data, the added secondary data, the defined sequence of operations, the one or more geometric subroutines, and the one or more calling features, the updated application data structure being stored on at least one of the one or more storage devices.

26. The apparatus of claim 24 or 25, wherein the one or more geometric subroutines comprise arguments for at least a portion of the parameter definition, the arguments controlling geometric operations and geometric dimensions of objects in geometric modeling operations associated with the physical system.

27. The apparatus of claim 24 or 25, wherein the one or more geometric subroutines comprise generating an output selection of: the output selection references a modeling operation in the built-in multi-physics model data structure.

28. A method performed in a computer system having one or more physical computing devices, the method configured to generate a modified application data structure for modeling a physical system, the method comprising acts of:

embedding, by the one or more physical computing devices, a multi-physics model data structure into an application data structure stored within one or more storage devices, the embedded multi-physics model data structure comprising at least one multi-physics modeling operation for the physical system being modeled;

adding, via one or more input devices, one or more geometric subroutines to the embedded multi-physics model data structure, at least one of the one or more geometric subroutines comprising a parameter definition associated with the physical system;

adding, via at least one of the one or more input devices, one or more geometric subroutine calls to the embedded multi-physics model data structure, the one or more geometric subroutine calls causing each geometric subroutine to be executed;

determining, by at least one of the one or more physical computing devices, one or more application features to be added to the application data structure, the one or more application features being associated with the physical system;

obtaining, by at least one of the one or more physical computing devices, application data representative of the determined one or more application characteristics, the application data including form data representative of at least one form characteristic for modeling the physical system and action data representative of at least one action characteristic for modeling the physical system; and

associating the action data representing the at least one action feature with the at least one modeling operation for the physical system defined in the embedded multi-physics model data structure, the association between the action data and the at least one modeling operation defining a sequence of operations for modeling the physical system.

29. The method of claim 28, further comprising an act of forming a modified application data structure comprising the obtained application data, the one or more geometric subroutines, and the one or more calling features, the modified application data structure being stored on at least one of the one or more storage devices.

30. The method of claim 28 or 29, further comprising:

receiving, by at least one of the one or more input devices, one or more input selections comprising geometric entities for the geometric subroutines, at least one of the input selections being associated with a set of geometric operations for the embedded multi-physics model data structure;

generating one or more geometric entity output selections in the embedded multi-physics model data structure by at least one of the one or more physical computing devices executing the geometric subroutine; and

generating a contribution to an accumulated geometric entity selection in the embedded multi-physics model data structure, the contribution associated with a geometric entity selection for a modeling operation in the model of the physical system.

31. The method of claim 28 or 29, further comprising:

receiving first position and orientation data of a previous end plane, the first position and orientation data for matching to an existing work plane defined in a geometric sequence of the geometric subroutines in the embedded multi-physics model data structure; and

generating second position and orientation data for matching the previous end plane with a new working plane, the generated second position and orientation data being accessible in the geometric sequence of the geometric subroutine in the multi-physics model data structure embedded.

32. The method of claim 28 or 29, further comprising: linking at least one of the one or more geometric subroutine calls to a second external one of the multi-physical field model data structures that is embedded.

33. The method of claim 28 or 29, wherein at least one of the one or more geometric subroutine calls is included within an if, else-if and/or else statement in the embedded multi-physics model data structure.

34. A method performed in a computer system comprising one or more processing portions, the method configured to generate an application model data structure for modeling a physical system, the method comprising acts of:

determining, by the one or more processing portions, a plurality of applications for modeling one or more physical systems, the plurality of applications defined by application data stored within one or more application data structures;

displaying a list of the plurality of applications in one or more graphical user interfaces;

receiving a first input indicating a first selection of at least one of the plurality of applications;

determining, by at least one of the one or more processing portions, one or more application features for the first selection of at least one of the plurality of applications, at least one of the one or more application features comprising a geometric operation of application data represented as: the application data is defined and retrieved in at least one of the one or more application data structures;

displaying the determined application feature in at least one of the one or more graphical user interfaces;

receiving a second input indicating a second selection of at least one of the plurality of application features, the second selection including an application feature for a geometric operation that calls a geometric subroutine;

determining, by at least one of the one or more processing portions, one or more settings of: the one or more settings for the geometric operation of at least one of the plurality of application features, the one or more settings including associated parameters for the modeling of the one or more physical systems;

displaying, via at least one of the one or more graphical user interfaces, an edit box that includes at least one of the one or more settings;

selecting at least one of the edit boxes; and

receiving, via one or more user input devices, an edit of the one or more settings included in the selected at least one edit box.

35. The method of claim 34, further comprising: generating, by at least one of the one or more processing sections, an application model data structure as follows: the application model data structure includes the received edits to the at least one or more settings of the at least one or more application features retrieved from the one or more application data structures.

36. The method of claim 35, further comprising the acts of:

determining, by at least one of the one or more processing portions, a sequence of actions defined in the generated application model data structure; and

executing, by at least one of the one or more processing sections, the sequence of actions.

37. The method of claim 36, further comprising an act of calling a geometric subroutine as part of the act of performing a geometric sequence.

38. The method of any one of claims 34-37, further comprising:

receiving, by at least one of the one or more input devices, one or more input selections, the one or more input selections comprising geometric entities for the geometric subroutines, at least one of the input selections being associated with a set of geometric operations for an embedded multi-physics model data structure;

generating one or more geometric entity output selections in the embedded multi-physics model data structure by executing at least one of the one or more processing portions of the geometric subroutine; and

generating a contribution to an accumulated geometric entity selection in the embedded multi-physics model data structure, the contribution associated with a geometric entity selection for a modeling operation in the model of the physical system.