US20160266877A1 - Systems and methods for creating user interfaces for guiding the creation of modeling applications for forming and solving problems in a multiphysics modeling system - Google Patents
Systems and methods for creating user interfaces for guiding the creation of modeling applications for forming and solving problems in a multiphysics modeling system Download PDFInfo
- Publication number
- US20160266877A1 US20160266877A1 US15/158,293 US201615158293A US2016266877A1 US 20160266877 A1 US20160266877 A1 US 20160266877A1 US 201615158293 A US201615158293 A US 201615158293A US 2016266877 A1 US2016266877 A1 US 2016266877A1
- Authority
- US
- United States
- Prior art keywords
- application
- widget
- data structure
- modeling
- user
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Abandoned
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/34—Graphical or visual programming
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/35—Creation or generation of source code model driven
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/38—Creation or generation of source code for implementing user interfaces
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/451—Execution arrangements for user interfaces
- G06F9/453—Help systems
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2111/00—Details relating to CAD techniques
- G06F2111/02—CAD in a network environment, e.g. collaborative CAD or distributed simulation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F30/00—Computer-aided design [CAD]
- G06F30/20—Design optimisation, verification or simulation
Abstract
Systems and methods generate a modified application data structure that provides a customized modeling of physical systems in response to customized user inputs received via application feature(s) for new window form(s). The modified application data structure is generated from guided user inputs received through application builder wizard graphical user interface(s). The systems and methods include embedding a multiphysics model data structure in an initial application data structure and defining new window form(s). Window form data representing the defined new window forms is added to the initial application data structure. User-selectable application feature options are displayed in the application builder wizard graphical user interface(s) and application feature data is added to the initial application data structure to create a modified application data structure. The added application features can include data representing widget(s), form feature(s), and command sequence(s).
Description
- This application claims priority to and the benefits of U.S. Provisional Application No. 62/050,014, filed on Sep. 12, 2014, the disclosure of which is hereby incorporated by reference herein in its entirety.
- The present invention relates generally to systems and methods for modeling and simulation, and more particularly, to systems and methods for providing user-selectable options to guide the creation of application data structures for forming and solving problems in a multiphysics modeling system.
- Computer modeling systems are used to develop product designs and can include graphical user interfaces. Computer modeling systems may be complemented with packages analyzing a single aspect of a design, such as, structural analysis. It would be desirable to have an improved multiphysics modeling system for developing designs that include user interfaces for customizing environments adapted to specific uses.
- According to one aspect of the present disclosure, a system is adapted to generate a modified application data structure for modeling physical systems. The modified application data structure is generated from guided user inputs received through one or more application builder wizard graphical user interfaces. The system comprises one or more modeling system processing units, one or more user input devices, optionally a display device, and one or more memory devices. The one or more modeling processing units are adapted, during use, to embed a pre-determined or a user-selected multiphysics model data structure in an initial application data structure. The multiphysics model data structure comprises data representing one or more models of physical systems. Each model of a physical system represents physical phenomena and/or physical processes. The multiphysics model data structure further comprises data representing at least one modeling operation for determining how to model or simulate the one or more models of physical systems. One or more new window forms are defined. In response to defining the one or more new window forms, window form data is added representing the defined one or more new window forms to the initial application data structure. One or more selections are received for application features from one or more user-selectable application feature options displayed in one or more of the application builder wizard graphical user interfaces. In response to receiving the one or more selections, application feature data are added corresponding to the received one or more selections. The application feature data represents one or more application features for the one or more new window forms. The application feature data is added to the initial application data structure to create a modified application data structure that further includes the window form data. Each added application feature comprises one or more of (i) first data representing at least one widget included in at least one of the new window forms, (ii) second data representing at least one form feature included in at least one of the new window forms, and/or (iii) third data representing at least one command sequence initiated through the at least one widget included in at least one new window form. The at least one form feature comprises one or more fields for specifying input data and/or output data and/or presentation format of input and/or output data. A command sequence comprises data specifying a sequence of operations to be carried out when executing an application defined by the modified application data structure. The at least one widget is linked to the command sequence such that selection of the at least one widget, during execution of the application, is operable to initiate the command sequence. The command sequence includes execution of at least one operation for the one or more models of physical systems defined in the embedded multiphysics model data structure. A modified application data structure is generated and stored in the one or more memory devices. The generated modified application data structure provides, when executed, a customized modeling of the physical systems in response to customized user inputs received via the one or more new window forms and the one or more application features for the one or more new window forms.
- According to another aspect of the present disclosure, a computer-implemented method generates a modified application data structure for modeling physical systems in a multiphysics modeling system. The modified application data structure is generated from guided user inputs received through one or more graphical user interfaces customized using an application builder wizard. The method comprises embedding, via one or more modeling system processing units, a pre-determined or user-selected multiphysics model data structure in an initial application data structure. The multiphysics model data structure comprises data representing one or more models of physical systems. Each model of a physical system represents physical phenomena and/or physical processes. The multiphysics model data structure further comprises data representing at least one modeling operation for determining how to model or simulate the one or more models of physical systems. In response to an input received via one or more user input devices, one or more new window forms are defined. In response to defining the one or more new window forms, window form data representing the defined one or more new window forms is added to the initial application data structure via at least one of the one or more modeling system processing units. One or more selections are received, via at least one of the one or more input devices, for application features from one or more user-selectable application feature options displayed in one or more of the application builder wizard graphical user interfaces. In response to receiving the one or more selections, application feature data corresponding to the received one or more selections is added via at least one of the one or more processing units. The application feature data represents one or more application features for the one or more new window forms. The application feature data is added to the initial application data structure to create a modified application data structure that further includes the window form data. Each added application feature comprises one or more of (i) first data representing at least one widget included in at least one of the new window forms, (ii) second data representing at least one widget collection included in at least one of the new window forms, (iii) third data representing at least one form feature included in at least one of the new window forms, (iv) fourth data representing at least one form collection feature included in at least one of the new window forms and/or (v) fifth data representing at least one command sequence initiated through the new window form. The at least one form feature or the at least one form collection feature comprises one or more fields for specifying input data and/or output data and/or presentation format of input and/or output data. The command sequence comprises data specifying a sequence of operations to be carried out when executing an application defined by the modified application data structure. The at least one widget or widget collection is linked to the command sequence such that selection of the at least one widget or widget collection, during execution of the application, is operable to initiate a command sequence. The command sequence includes execution of at least one operation for the one or more models of physical systems defined in the embedded multiphysics model data structure. The modified application data structure is generated via at least one of the one or more modeling processing units. The generated modified application data structure is stored on one or more memory devices of the multiphysics modeling system. The generated modified application data structure provides, when executed, a customized modeling of the physical systems in response to customized user inputs received via one or more new window forms and one or more application features for the one or more new window forms.
- Additional aspects of the present disclosure will be apparent to those of ordinary skill in the art in view of the detailed description of various embodiments, which is made with reference to the drawings, a brief description of which is provided below.
- Features and advantages of the present disclosure will become more apparent from the following detailed description of exemplary embodiments thereof taken in conjunction with the accompanying drawings in which:
-
FIG. 1A-1C illustrate exemplary aspects of computer and server systems for creating user interfaces for guiding the creation of applications for forming and solving problems in a multiphysics modeling system according to aspects of the present disclosure. -
FIG. 2 illustrates an exemplary aspect of computer systems that may reside and be executed in one of the hosts ofFIG. 1A according to aspects of the present disclosure. -
FIG. 3 illustrates a flowchart for exemplary aspects of a method for creating user interfaces for guiding the creation and modification of an application data structure according to aspects of the present disclosure. -
FIG. 4 illustrates an exemplary aspect of graphical user interfaces for a method step of creating an initial application data structure including adding a new window form, according to aspects of the present disclosure. -
FIG. 5 illustrates a graphical user interface for adding an application feature that includes adding a new form to an application data structure according to aspects of the present disclosure. -
FIG. 6 illustrates a graphical user interface for adding a button widget to a new form and linking the widget to a command sequence in an embedded multiphysics model for a physical system, according to aspects of the present disclosure. -
FIG. 7 illustrates a graphical user interface for selecting a form layout and for adding additional new forms in an application data structure according to aspects of the present disclosure. -
FIG. 8 illustrates a graphical user interface for adding an output form to an application data structure according to aspects of the present disclosure. -
FIG. 9 illustrates a graphical user interface for an exemplary settings window for editing settings for a main window of a modeling application created using the application builder wizard according to aspects of the present disclosure. -
FIG. 10 illustrates a graphical user interface for an exemplary settings window for a static window node of a modeling application created using the application builder wizard, according to aspects of the present disclosure. -
FIG. 11 illustrates a graphical user interface for an exemplary settings window for a single window form node of a modeling application created using the application builder wizard, according to aspects of the present disclosure. -
FIG. 12 illustrates a graphical user interface for an exemplary settings window for a form reference of a modeling application created using the application builder wizard, according to aspects of the present disclosure. -
FIG. 13 illustrates a graphical user interface for an exemplary settings window for a label widget of a modeling application created using the application builder wizard, according to aspects of the present disclosure. -
FIG. 14 illustrates a graphical user interface for an exemplary settings window for an input field widget of a modeling application created using the application builder wizard, according to aspects of the present disclosure. -
FIG. 15 illustrates a graphical user interface for an exemplary settings window for a unit label widget of a modeling application created using the application builder wizard, according to aspects of the present disclosure. -
FIG. 16 illustrates a graphical user interface for an exemplary settings window for a button widget of a modeling application created using the application builder wizard, according to aspects of the present disclosure. -
FIG. 17 illustrates a graphical user interface for an exemplary settings window for a graphics widget of an application of a modeling application created using the application builder wizard, according to aspects of the present disclosure. -
FIG. 18 illustrates a graphical user interface for an exemplary settings window for a command sequence method of a modeling application created using the application builder wizard, according to aspects of the present disclosure. -
FIG. 19 illustrates a flowchart for exemplary aspects of a method for modifying an initial application data structure, according to aspects of the present disclosure. -
FIG. 20 illustrates an exemplary unified modeling language (UML) object diagram of instance level relationships between components according to aspects of an application data structure created and modified by the method ofFIG. 3 . -
FIG. 21 illustrates a graphical user interface for positioning input forms, output forms, and form collections in a window form according to aspects of the present disclosure. -
FIG. 22 illustrates an exemplary flowchart of method steps for interpreting an application data structure for generating and maintaining an application model tree, context menu, and settings window, according to aspects of the present disclosure. -
FIG. 23 illustrates an exemplary flowchart of method steps for interpreting an application model data structure, according to aspects of the present disclosure. - While the present disclosure is susceptible to various modifications and alternative 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. Rather, the invention is to cover all modifications, equivalents, and alternatives falling within the spirit and scope of the invention as defined by the appended claims.
- While this invention is susceptible of embodiment in many different forms, there is shown in the drawings and will herein be described in detail preferred aspects of the invention 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 the aspects illustrated. For purposes of the present detailed description, the singular includes the plural and vice versa (unless specifically disclaimed); the word “or” shall be both conjunctive and disjunctive; the word “all” means “any and all”; the word “any” means “any and all”; and the word “including” means “including without limitation.”
- Exemplary methods and systems are described for an application builder wizard that automates and simplifies complex tasks associated with creating a modeling application and the corresponding application data structure. The application builder wizard provides an efficient system that guides a user through a series of user-selectable options, displayed in one or more application builder wizard graphical user interfaces the selections of which are subsequently used to build an application data structure for modeling applications of complex multiphysics systems. The application data structure is used during the execution of applications that are based on a multiphysics model. In some aspects, modeling applications are based on existing multiphysics models that are embedded in application data structures.
- It may be desirable for the application builder wizard described herein to be available to a modeling system user when the user of the multiphysics modeling system saves a multiphysics model as an application. It is also contemplated that it would be desirable to use an application data structure created by an application builder wizard in an application interface builder system (e.g., see Application Builder available from COMSOL, Inc. in COMSOL Multiphysics v4.4 and later versions for creating applications based on multiphysics models), such as the systems described in U.S. Patent Publication No. 2014/0047407, published on Feb. 13, 2014, and International Publication No. WO 2014/100727 A1, published Jun. 26, 2014, the disclosures of which are incorporated by reference herein in their entireties. Through the application builder wizard described by the present disclosure, an application data structure can be created and/or modified by adding forms, widgets, sequences of operations, methods, and/or events.
- Multiphysics modeling systems as contemplated by the present disclosure include such systems as COMSOL Multiphysics® Version 4.4 and other versions, that are available from COMSOL, Inc. of Burlington, Mass., USA, and the multiphysics modeling systems described in U.S. Pat. Nos. 7,596,474 and 8,626,475, the disclosures of which are incorporated by reference herein in their entireties. Multiphysics modeling systems include features for setting up and solving multiphysics problems for simulations that include a plurality of coupled physical phenomena. The systems provide for receiving inputs in the form of physical properties that may be expressed in terms of physical quantities. The modeling system can further provide for setting up problems using physical properties, physical quantities, and physical phenomena described using partial differential equations (PDEs). The described multiphysics modeling system include features setting up and solving multiphysics problems using predefined physics interfaces, which are also referred to as application modes in U.S. Pat. No. 7,596,474. In addition, the described multiphysics modeling systems include PDE interface, also referred to as PDE modes, where a predefined physics interface is not available. The benefit or desirability of the described physics interfaces over the use of generic PDE modes (or PDE interfaces) for setting up multiphysics problems is that generic PDE modes (or PDE interfaces) require knowledge about the description of physical properties, physical quantities, and physical phenomena in terms of PDEs, whereas the predefined physics interfaces greatly simplify the process for describing the physical properties, physical quantities, and physical phenomena.
- Earlier multiphysics modeling systems provided for the creation of applications based on a model formulation such as the waveguide elbow discussed in more detail in U.S. Pat. No. 7,596,474, which is incorporated herein by reference in its entirety. Physics interfaces (or application modes as discussed above) and physics interface settings for multiphysics modeling systems are directed to a specific physics phenomena. An application and application settings in a multiphysics modeling system may include accessing a limited set of parameters, variables, physical properties and physical quantities in a multiphysics model. Thus, in contrast to physics interface settings, the application settings may be tailored for a very specific use rather than a physics phenomenon. For example application settings may include settings for parameters that control a parameterized geometric representation of the multiphysics model.
- U.S. Patent Publication No. 2014/0047407, published on Feb. 13, 2014, and International Publication No. WO 2014/100727 A1, published Jun. 26, 2014 describe an aspect of a system and method for creating an application data structure, based on a multiphysics model, from a dedicated graphical user interface in an application builder software for accessing features and feature settings for the multiphysics model. Such a graphical user interface gives access to methods for generating a data structure representing an application using the existing settings for the multiphysics model. The application data structure is then interpreted by another method to make it accessible from the graphical user interface in a multiphysics modeling software for generating an application model data structure and a multiphysics model data structure for simulations.
- As discussed above and in more detail below, this disclosure refers to a number of components for modeling systems, including reference to different types of builders along with the data structures that the builders create.
- In some aspects, the different components of a multiphysics modeling system can include a model builder, a physics builder, and an application builder. Typically, each of these builders includes graphical user interfaces for receiving model inputs from a system user. A model builder can include executable methods for creating multiphysics models, where the methods include, for example, receiving input(s) for physics properties as functions of physics quantities. The model builder then produces a set of coupled PDEs using two or more physics interfaces.
- In some aspects, a physics builder can include executable methods for creating interfaces for the creation of multiphysics models. The physics builder can include methods for receiving inputs in the form of PDEs, coefficients of PDEs and interface components for settings of the PDEs and the PDE coefficients. The physics builder then creates physics interfaces that can be used in the model builder.
- In some aspects, an application builder can include methods for creating application interfaces for running multiphysics models. The application builder can include methods for receiving inputs for defining interface components that can be used to modify and run embedded multiphysics models that are stored as multiphysics model data structures. The multiphysics models are embedded in an application data structure. In some aspects, the multiphysics models are initially created by the model builder from an application interface.
- In some aspects, a multiphysics model data structure includes modeling components, such as but not limited to, modeling operations and commands for one or more physical systems. An application data structure includes an embedded multiphysics model data structure along with additional data representing user interface components, such as but not limited to, widgets, widget collections, forms, form collections, and window forms, that may be linked to the modeling operations and commands contained within the embedded multiphysics data structure. The application data structure can then be interpreted, creating an application model data structure. The application model data structure is an instantiation of an application data structure where the application interface may be accessible from various graphical user interfaces.
- A desirable aspect of the application builder wizard is that it guides a system user in creating an application data structure that can be used for executing applications. Such an application can be based on an existing multiphysics model that is embedded in the application data structure. It may also be desirable to show such an application builder wizard when the user of a multiphysics modeling system saves a multiphysics model as an application. It would further be desirable to use the application data structure created by an application builder wizard in an application builder to modify an existing application data structure by adding forms, widgets, methods, and events.
- In some non-limiting aspects of the systems herein, an application builder wizard includes instructions for guiding system users that includes providing or displaying one or more lists of user-selectable options. The listed options can be categorized, such as under various user selectable tabs (e.g., input/output; plots; graphics, buttons) that allow the desired modeling operations to be easy to find and to significantly simplify the modeling process, particularly for developing customized modeling applications. In some aspects, it is contemplated that listed user-selectable options (e.g., modeling operation) may be included in a second list of options or in a plurality of second lists of options that appear following the receipt of a selection from the first list of options. For example, widgets, widget collections, forms and form collections can be created for an application using the application builder wizard, based on the selections from the one or more user-selectable options including the second list(s) of options. Following the user selections, in some aspects, the application builder wizard automatically displays the created widgets, widget collection, forms, and/or form collections in a preview of a window displayed in graphical user interface, thereby allowing a system user to view the created item and speeding up the application building process. The widgets, widget collections, forms, and/or form collections can further be automatically linked to the selected modeling operations.
- In another non-limiting aspect, a system for generating a modified application data structure for modeling physical systems is generated from guided user inputs received through an application builder wizard. The system guides the user by presenting to the user a GUI window displaying lists along with a preview in response to a user selection for creating a new application window form. For example, the user selection may occur by the selection of a “New Form” button display in the window. A first group of lists can comprise a list of items, representing modeling operations, available in an embedded multiphysics model. The first group of lists can include (i) a first list of input/output modeling operations, (ii) a second list of graphics modeling operations, and/or (iii) a third list including command sequences for modeling operations. The GUI window can also display a second group of lists including (a) a first list of selections, including selected input/output modeling operations, (b) a second list of selections, including selected graphics modeling operations, and/or (c) a third list of selections, including command modeling operations. In response to a user selecting one or more modeling operations from the first, second, or third lists of modeling operations, the selected modeling operations are added to the respective first, second, and/or third lists including the selected modeling operations. In response to a modeling operation being added to one of the lists of selected modeling operation, a widget, a widget collection, a form, and/or a form collection are linked to the modeling operation. A preview of the new application window form showing the created widgets, widget collections, forms, and/or form collections, arranged according to default settings, are displayed in a preview area of the GUI window.
- An application builder wizard for generating application data structures and for modifying application data structures used in multiphysics modeling systems can be executed as part of an application builder or it may be a standalone system. The standalone system can interface or connect with an engineering analysis system, such as a multiphysics modeling system. It is also contemplated that the application builder wizard may be a one of or a part of a plurality of modules or components, that include instructions, which comprise an engineering analysis system. An application builder wizard component can include or be connected with a user interface, such as a graphical user interface, that seeks inputs and displays instructions to a system user. The application builder wizard can be executed on one or more modeling system processing units associated with various computer systems described elsewhere herein including, among other things, the computer and/or server systems and apparatus described for multiphysics modeling systems.
- It is contemplated to be desirable for the application builder wizard to be available in, or accessible to, an engineering analysis system, such as a multiphysics modeling system which may generate a model, described in a model object (e.g., a model data structure including data fields and methods along with their interactions) in accordance with an object-orient programming language (e.g., C++, C#, Java®).
- Systems for computer aided engineering, such as finite elements analysis systems, finite volume systems, computational fluid dynamics (CFD) systems, and multiphysics modeling systems are often equipped with a graphical user interface where a user may set up and run a simulation. Such processes or systems may contain a number of different user interfaces for different types of simulations, such as CFD, heat transfer, electromagnetics, or structural mechanics simulations.
- Methods for setting up and solving multiphysics problems and other modeling systems are described in U.S. Pat. No. 8,219,373, issued Jul. 10, 2012; U.S. Pat. No. 7,623,991, issued Nov. 24, 2009; U.S. Pat. No. 7,519,518, issued Apr. 14, 2009; U.S. Pat. No. 7,596,474, issued Sep. 29, 2009; and U.S. Patent Application Publication No. 2012/0179426, published Jul. 12, 2012, each of which are hereby incorporated by reference herein in their entireties. These published patent documents describe, for example, methods for setting up and executing multiphysics simulations, including several coupled physical phenomena, by receiving inputs in the form of physical properties that may be expressed in terms of physical quantities. In addition, the above-referenced U.S. patents and patent application disclose methods for setting up problems using physical properties, physical quantities, and physical phenomena described using partial differential equations (PDEs). Some of the above-referenced published patent documents provide for methods and systems for setting up and solving multiphysics problems using predefined application modes that are otherwise referred to in the present disclosure, and in some of the other referenced patent documents, as physics interfaces. Components of the physics interfaces can include parameters, variables, physical properties, physical quantities, boundary and initial conditions, and solvers with settings and menus along with various other physics interface components, such as input fields for setting or defining parameters, variables, physical properties, physical quantities, boundary and initial conditions, and solvers. These settings and menus may be tailored for the specific physics instead of using the generic mathematical settings. In addition, these published patent disclosures also describe methods for PDE modes, also referred to as PDE interfaces, in the cases where predefined physics interfaces are not available. The use of the generic PDE modes and PDE interfaces for setting up multiphysics problems requires knowledge about the description of physical properties, physical quantities, and physical phenomena in terms of PDEs.
- It is contemplated that systems and methods operable to or adapted to automate and simplify the generation of an application data structure and/or the modification of an application data structure, based on a multiphysics model, would be desirable and provide various computational advantages for engineering design systems, including modeling and simulation systems. The methods and systems for generating or modifying an application data structure can be implemented on dedicated graphical user interface(s) in an application builder wizard that is configured to or adapted to guide a user through the creation and/or modification of an application data structure.
- Throughout this disclosure, various non-limiting exemplary aspects of systems are described that include methods, executed on one or more modeling system processing unit(s), which are accessible via a graphical user interface. The methods include instructions for guiding system users through the generating and/or modifying of application data structures for modeling physical systems. It is contemplated that the generated and/or modified application data structures can be applied or associated with an engineering analysis system (e.g., a multiphysics modeling system), where the data structure(s) may be built and applied by a system user.
- Physical computing devices embodying engineering analysis, modeling, and/or simulation systems may be configured with one or more graphical user interfaces that allow a system user to input and execute simulations and build or modify application data structures. The computer systems can include different interfaces for different types of simulations. Different user interfaces may, for example, be provided for fluid flow, heat transfer, electromagnetic, and/or structural mechanics simulations.
- A system having a dedicated graphical user interface for generating or modifying an application data structure and an application model data structure are contemplated in some aspects of the present disclosure. For example, a computer system may include a graphical user interface and provide windows with user-selectable options for defining the parameters, forms (e.g., application window form), features (e.g., form; widget), actions (e.g., command sequence), variables, physical properties, physical quantities, and/or physics interface features for a desired physics phenomena associated with a desired analysis or simulation. The graphical user interface can allow access to routines or methods that then generate or modify an application data structure. The generated or modified data structure(s) may then be interpreted or processed by a routine or method configured to create or modify the application model data structure and to make the application interface accessible from other graphical user interface(s) associated with, for example, an engineering analysis system such as a multiphysics modeling system. It is contemplated that the routines or methods for these operations can be executed locally on, and/or remotely through network connection(s) to, one or more modeling system processing unit(s), either dedicated or shared, executing the engineering analysis systems.
- Computer systems may be used for performing the different tasks described in the present disclosure. One aspect for using a computer system includes executing one or more computer programs, including engineering analysis systems and methods, stored on computer readable media (e.g., temporary or fixed memory, magnetic storage, optical storage, electronic storage, flash memory, other storage media). A computer program may include instructions which, when executed by a modeling system processing unit, perform one or more tasks. In certain embodiments, a computer system executes machine instructions, as may be generated, for example, in connection with translation of source code to machine executable code, to perform modeling and simulation, and/or problem solving tasks. One technique, which may be used to model and simulate physical phenomena or physical processes, is to represent various physical properties and quantities, of the physical phenomena or physical processes being modeled and simulated, in terms of variables and equations or in other quantifiable forms that may be processed by a computer system. In turn, these equations or other quantifiable forms may be solved by a computer system configured to solve for one or more variables associated with the equation, or the computer may be configured to solve a problem using other received input parameters.
- It is contemplated that computer programs for modeling and simulating physical phenomena or physical processes along with systems that provide for the building of applications interfaces for modeling systems, provide many advantages particularly as the complexity of the physical phenomena or physical processes being modeled and simulated increases. For example, in certain embodiments a user can combine one or more physical phenomena into a multiphysics model, as part of, for example, an engineering analysis. To further illustrate this example, a user may combine phenomena described by chemical kinetics and fluid mechanics, electromagnetic phenomena and heat transfer, structural mechanics and fluid flow, or other physics phenomena. Such multiphysics models may also involve multiple physical processes. For example, a process may be combined that includes an amplifier powering an actuator, where both the amplifier and the actuator are a part of one multiphysics model. Multiphysics modeling can also include solving coupled systems of partial differential equations (PDEs).
- It is contemplated that computer systems on which modeling systems operate, such as the modeling systems described herein, can include networked computers or processors. In certain embodiments, modeling system processing units may be operating directly on the modeling system user's computer (e.g., a host or client), and in other embodiments, a modeling system processing unit may be operating remotely (e.g., a remote server system). For example, a user may provide various input parameters at one computer or terminal located at a certain location. Those parameters may be processed locally on the one computer or the parameters may be transferred over a local area network or a wide area network, to another processor, located elsewhere on the network that is configured to process the input parameters. The second processor may be associated with a server connected to the Internet (or other network) or the second processor can be several processors connected to the Internet (or other network), each handling select function(s) for developing and solving a problem on the modeling system. It is further contemplated that the results of the processing by the one or more processors can then be assembled at yet another server or processor. It is also contemplated that the results may be assembled back at the terminal or computer where the user is situated. The terminal or computer where the user is situated can then display the solution of the multiphysics modeling system to the user via a display (e.g., a transient display) or in hard copy form (e.g., via a printer). Alternatively or in addition, the solution may be stored in a memory associated with the terminal or computer, or the solution may be stored on another server that the user may access to obtain the solution from the modeling system.
- It is contemplated that in certain embodiments a product or process may be in the development or feasibility stage where it is being designed or analyzed. The product or process being developed or analyzed may need to be assessed for use in complex environment(s) involving several physical properties and quantities. It can be desirable to solve complex multiphysics problems by systematically varying parametric and geometric features in a computer-based design system. Other desirable features may include, for example, having a computer-based system for solving complex multiphysics problems in which the settings for the physical properties and boundary conditions, located in a memory and used to form multiphysics models and/or solve multiphysics problems, can be accessed directly from the design system.
- Referring now to
FIGS. 1A-1C , exemplary aspects of computer and server systems are illustrated that may be used with the methods described herein including modeling systems and application builder wizard systems for generating or modifying application data structures. -
FIG. 1A illustrates acomputer system 110 that includes adata storage system 112 connected to host systems 114 a-114 n throughcommunication medium 118. In some aspects, data storage systems may also be hosted locally on any one of the host systems 114 a-114 n. Incomputer system 110, the “n” hosts 114 a-114 n may access thedata storage system 112, for example, in performing input/output (I/O) operations. Thecommunication medium 118 for communicatively connecting the various system components may be any one of a variety of networks or other type of communication connections as known in the modeling and computer simulation field. For example, thecommunication medium 118 may be the Internet, an intranet, or other network connection by which the host systems 114 a-114 n may access and communicate with thedata storage system 112, and may also communicate with others included in thecomputer system 110, including without limitation systems based on various forms of network communications (e.g., fiber optic, wireless, Ethernet). - Each of the host systems 114 a-114 n and the
data storage system 112 included in thecomputer system 110 may be connected to thecommunication medium 118 by any one of a variety of connections as may be provided and supported in accordance with the type ofcommunication medium 118. The processors included in the host computer systems 114 a-114 n or a data manager system may be any one of a variety of commercially available single or multi-processor system, such as an Intel-based processor, server, or other type of commercially available processor able to support incoming traffic in accordance with each particular embodiment and application. - It should be noted that the particulars of the hardware and systems included in each of the host systems 114 a-114 n, as well as those components that may be included in the
data storage system 112 are described herein in more detail, and may vary with each particular embodiment. Each of the host computers 114 a-114 n, as well as thedata storage system 112, may all be located at the same physical site, or, alternatively, may also be located in different physical locations. Examples of the communication medium that may be used to provide the different types of connections between the host computer systems, the data manager system, and the data storage system of thecomputer system 110 may use a variety of different communication protocols such as SCSI, ESCON, Fiber Channel, or functional equivalents that are known to those skilled in the computer modeling and simulation field. Some or all of the connections by which the hosts anddata storage system 112 may be connected to thecommunication medium 118 may pass through other communication devices, such as a Connectrix or other switching equipment that may exist, both physical and virtual, such as a phone line, a repeater, a multiplexer or even a satellite. - Each of the host computer systems may perform different types of data operations, such as storing and retrieving data files used in connection with an application executing on one or more of the host computer systems. For example, a computer program may be executing on the
host computer 114 a and store and retrieve data from thedata storage system 112. Thedata storage system 112 may include any number of a variety of different data storage devices, such as disks, tapes, and the like in accordance with each implementation. As will be described in following paragraphs, methods may reside and be executing on any one of the host computer systems 114 a-114 n. Data may be stored locally on the host system executing the methods, as well as remotely in thedata storage system 112 or on another host computer system. Similarly, depending on the configuration of eachcomputer system 110, methods as described herein may be stored and executed on one of the host computer systems and accessed remotely by a user on another computer system using local data. A variety of different system configurations and variations are possible then as will be described in connection with the embodiment of thecomputer system 110 ofFIG. 1 and should not be construed as a limitation of the techniques described elsewhere herein. - Turning now to
FIG. 1B , another non-limiting exemplary aspect of a system adapted to generate a modified application data structure is described. The system can include one or moreclient processing systems server system 20 communicatively connected to the client processing system(s). Theserver system 20 includes aserver processing unit 23. The client processing system(s) 14 a-n can also receive output data and output commands from the server system where the output data and output commands correspond to the user input previously sent to theserver system 20. The client processing system(s) 14 a-n and theserver system 20 can each include their owndata storage components - The
server system 20 can include components, that upon execution, receive input data and input commands from communicatively connected client processing system(s) 14 a, 14 b . . . 14 n. In some aspects, theserver system 20 can further include executable components for sending input data to and receiving data from acontrol server computer 30 that includes acontrol server processor 33 and may also havedata storage components 32. The control server computer can be used to control access to certain operations of a modeling system. Theserver system 20 can also include executable components for generating output data and output commands based on the received input data, input commands, and/or control data; and send these output data and output commands to any one of the client processing system(s) 14 a-n. In some aspects, theserver system 20 may further include executable components to verify if an input command may be executed, as determined by the received control data. - Modeling processing units, display devices, and/or memory device are contemplated to be a part of the client processing systems 14 a-n,
server system 20, and/orcontrol server system 30. - Turning now to
FIG. 1C , a further non-limiting exemplary aspect of a system adapted to generate a modified application data structure is described. The system can include aclient processing system 50 that includes executable components for agraphical user interface 53, where user input may be received and output may be displayed. The client processing system can store user data generated through user input and output received from aserver system 60. The client processing system may also locally store executable software component libraries which are used to display graphical user interface(s), receive input, generate input commands, execute output commands, and display output. User data can be stored on client userdata storage component 58 or on a server system userdata storage component 68. Similarly library data can be stored locally on a clientlibrary storage component 56. - In one illustrative aspect, user input may be received via the
GUI 53 of theclient processing system 50 based on a user selecting an option via theGUI 53 to create an exemplary geometry, such as a cylinder geometry. The input and input commands may be sent to the communicatively connectedserver system 60. Output data and output commands received from the server system can then be executed on theclient processing system 50 to render and display the exemplary cylinder geometry and to refresh thegraphical user interface 53, based on the exemplary user input for a cylinder. Thus, theserver system 60 can receive user input data and input commands from aclient processing system 50 and use the received data and commands to generate output data and output commands that can be received by theclient processing system 50. These output data and output commands determine what will be shown in thegraphical user interface 53 in theclient processing system 50 and are based on the user input. - The server system can include executable components that determine logics associated with a modeling system. For example, upon execution of
logics component 64, which is similar to an application program interface component, thelogics component 64 can receive input data and input commands from theclient processing system 50 and determine how to process received input. Thelogics component 64 can determine which modeling and simulation software components should be used to process input data and execute input commands, and which components should be used to generate output data and output commands, based on the user input. The input data and input commands may be relayed by the logics component(s) 64, upon execution, to one or more of rendering, geometry, physics, meshing, assembling, solver, and results components, collectively referred to inFIG. 1C ascomponent 65. The output data and the output commands fromcomponent 65 can then be relayed to theclient processing system 50 by thelogics components 64. - The
server system 50 may store and accesslogics component libraries 66. Theserver system 50 may also storeuser data 68 used by thelogics components 64. As discuss above, theserver system 50 may also include aspects for rendering the graphical user interface incomponent 65, that builds the geometry, defines the physics, generates the mesh, assembles the numerical model, solves the numerical model, and generates the output data and output commands, in an application builder or multiphysics modeling software. Continuing on the illustrative example of the cylinder, alogics component 64 can receive user input in the form of input data and input commands for generating a cylinder and send these data and commands to a geometry component that is part ofcomponent 65. The geometry component executes the cylinder command and sends an output to the rendering component that is also a part ofcomponent 65. Thelogics component 64 may then receive the output from the rendering component and send rendering data, for the cylinder geometry together with its settings, to theclient processing system 50 for display in thegraphical user interface 53. - The
server system 60 may also store andaccess library components 66 for rendering, building the geometry, generating the mesh, assembling the numerical model, solving the numerical model equations, and generating the results. - In some aspects, the
graphical user interface 53 and thelogics components 64 may send data and commands that may be trigger a control check in the rendering, geometry, physics, meshing, assembling, solvers, and results components ofcomponent 65, which then may generate a request that is sent to acontrol server 70. Theserver system 60 may then receive data fromcontrol server system 70 that is used to determine if it should allow the execution of commands. The data sent to theserver system 60 from thecontrol server system 70 is generated by thecontrol server 73 using a file that may be stored, for example in thelibraries component 72, of thecontrol server system 70. - Modeling processing units, display devices, and/or memory device are contemplated to be a part of the
client processing system 50,server system 60, and/orcontrol server system 70. - Referring now to
FIG. 2 , an exemplary aspect of amodeling system 219 is illustrated that may reside, for example, on a single computer or in one of a plurality of host computer systems (such as host computers 114 a-114 n illustrated inFIG. 1A ). The modeling system may be divided into several components. One exemplary aspect of the system may include aGUI module 220, a Modeling andSimulation module 222, and a Data Storage andRetrieval module 224. TheGUI module 220 can provide for interactions with system users. The Modeling andSimulation module 222 can provide an ability to manage and perform a multiphysics simulation. The Data Storage andRetrieval module 224 can provide an ability to load and save the model in a file, and to load and store other types of files which may be used during the simulation or may be used as input or output to the simulation. - The
GUI module 220 may communicate with the Modeling andSimulation module 222 by sending and receiving commands. As may also occur on the other computer and server systems described herein, the act of sending and receiving commands may be performed through an application programming interface (“API”) or other similar components. In one aspect of the system, the API may be object oriented, and mix data and function calls within the same structure. In another aspect of the system, the API may use a data structure that is separate from function calls. - It is contemplated that the
GUI module 220 can include a plurality of modeling system, such as a multiphysics model builder interface, an application builder interface, a form editor interface, and/or an application builder wizard interface for creating application data structures. The application builder wizard interface may operate in the GUI module and may also interface with other modules such as the Modeling andSimulation Module 222 and/or the Data Storage andRetrieval Module 224. - It is contemplated that in certain aspects of the present disclosure components of the multiphysics modeling system may reside on different host computer systems. For example, the
GUI module 220 may reside on a personal computer host and the Modeling andSimulation module 222 may reside on a server computer host. It is further contemplated that the Data Storage andRetrieval module 224 may reside on either the personal computer host or the server computer host, or yet another separate computer host. If the computer hosts are not identical, the API can be configured to use a computer network to communicate between hosts. In one embodiment, an object-oriented API may be configured to send data and method calls over the computer network or in another embodiment send data and function calls between the components over a computer network. The API may also be able to handle a Data Storage andRetrieval module 224 which may be located either on the host of theGUI module 220 or the Modeling andSimulation module 222, or on a separate host. In each of those cases, the Data Storage andRetrieval module 224 may be configured to load and store files on each of those hosts. - It is contemplated that in certain aspects, the
system 219 may include, or be configured with, operating systems such as Windows 8, Mac OS, iOS, Android, Chrome OS, and the like, or system components other than what is described and represented in themodeling system 219 illustrated inFIG. 2 . In the exemplary aspect illustrated inFIG. 2 ,Libraries 226 and theUser Data Files 228 can be stored locally within the host computer system. It is further contemplated that in certain aspects, theLibraries 226 and/orUser Data Files 228, as well as copies of these, may be stored in another host computer system and/or in theData Storage System 112 of thecomputer system 110. However, for simplicity and explanation in paragraphs that follow, it may be assumed in a non-limiting manner that thesystem 219 may reside on a single host computer system such as 114 a with additional backups, for example, of the User Data Files and Libraries, in theData Storage System 112. - In certain aspects of the present disclosure, portions of the
modeling system 219, such as theGUI module 220, the Modeling andSimulation module 222, the Data Storage andRetrieval module 224, and/or theLibraries 226 may be included or executed in combination with commercially available system package(s). These components may operate on one of the host systems 114 a-114 n, and may include one or more operating systems, such as, Windows XP®, Windows 7, Windows 8, Windows HPC Server 2008 R2, Unix®, Linux®, Mac OS®, iOS, Chrome® OS, Android®, and the like. It is further contemplated that the modules of themodeling system 219 may written in any one of a variety of computer programming languages, such as, C, C++, C#, Java®, or any combination(s) thereof, or other commercially available programming languages. - It is contemplated that the
GUI module 220 may display GUI windows in connection with obtaining data for use in performing modeling, simulation, and/or other problem solving for one or more processes and/or physics phenomena under consideration by a system user. The one or more processes and/or phenomena may be assembled and solved by the Modeling andSimulation module 222. That is, user data may be gathered or received by the system using modules, such as theGUI module 220, and subsequently used by the Modeling andSimulation module 222. Thereafter, the data may be transferred or forwarded to the Data Storage andRetrieval module 224 where the user-entered data may be stored in a separate data structure (e.g., User Data Files 228). It is contemplated that other data and information may also be stored and retrieved from a separate data structure, such asLibraries 226, which may be used by the Modeling andSimulation module 222 or in connection with theGUI module 220. - The various data files that may be associated with a modeling system, such as
User Data Files 228 and theLibraries 226, may be stored in any one of a variety of data file formats in connection with a file system used in the host computer system or in theData Storage System 112. In certain aspects, thesystem 219 may use any one of a variety of database packages in connection with the storage and retrieval of data. The User Data files 228 may also be used in connection with other simulation and modeling systems. For example, the User Data files 228 may be stored in a format that may also be used directly or indirectly as an input to any one of a variety of other modeling systems. In certain aspects, data may be imported and/or exported between the multiphysics modeling system and another system. The format of the data may be varied or customized in accordance with each of the system(s) as well as in accordance with additional functionalities that each of the system(s) may include. - It is contemplated that the systems and methods described herein may be used for combining a plurality of physics interfaces to create a multiphysics model for modeling different physical phenomena or processes. Properties of the physics interfaces can be represented by PDEs that may be automatically combined to form PDEs describing physical quantities in a coupled system or representation. It is contemplated that the PDEs may be provided to the solver either independently as one PDE or a system of PDEs, describing a single phenomenon or process, or as one or several systems of PDEs describing several phenomena or processes.
- It is contemplated that in certain aspects of the present disclosure physical properties can be used to model physical quantities for component(s) and/or process(es) being examined using the modeling system, and the physical properties can be defined using a GUI that allow the physical properties to be described as numerical values. In certain aspects, physical properties can also be defined as mathematical expressions that include one or more numerical values, space coordinates, time coordinates, and/or the actual physical quantities. In certain aspects, the physical properties may apply to some parts of a geometrical domain, and the physical quantity itself may be undefined in the other parts of the geometrical domain. A geometrical domain or “domain” may be partitioned into disjoint subdomains. The mathematical union of these subdomains forms the geometrical domain or “domain”. The complete boundary of a domain may also be divided into sections referred to as “boundaries”. Adjacent subdomains may have common boundaries referred to as “borders”. The complete boundary is the mathematical union of all the boundaries including, for example, subdomain borders. For example, in certain aspects, a geometrical domain may be one-dimensional, two-dimensional, or three-dimensional in a GUI. However, as described in more detail elsewhere herein, the solvers may be able to handle any space dimension. It is contemplated that through the use of GUIs in one implementation, physical properties on a boundary of a domain may be specified and used to derive the boundary conditions of the PDEs.
- Additional features of a modeling system, such as feature that may be found in the Modeling and
Simulation module 222, may provide for automatically deriving a system of PDE's and boundary conditions for a multiphysics model. This technique can include merging the PDEs of the plurality of phenomena or processes, and may produce a single system of coupled PDEs, also using coupling variables or operators to couple processes in different coordinate systems, and may perform symbolic differentiation of the system of PDEs with respect to all the dependent variables for later use by the solver. - It is contemplated that certain aspects of the present disclosure may include features for modeling one or more of a plurality of engineering and scientific disciplines, including, for example, acoustics, chemical reactions, diffusion, electromagnetism, fluid mechanics, geophysics, heat transfer, optics, plasma physics, quantum mechanics, semiconductor physics, structural mechanics, wave propagation, and the like. Certain aspects of a modeling system may involve more than one of the foregoing disciplines and can also include representing or modeling a combination of the foregoing disciplines. Furthermore, the techniques that are described herein may be used in connection with one or more systems of PDEs.
- Referring now to
FIGS. 3 to 8 , exemplary aspects of an application builder wizard are described. The application builder wizard is a system that creates or modifies an initial application data structure that is stored in one or more memory devices associated with a multiphysics modeling system. The generated application data structure, when executed on physical processing unit(s) of a multiphysics modeling system, provides a customized modeling of physical system(s). Each model of a physical system represents physical phenomena and/or physical processes. A multiphysics model data structure including data representing at least one modeling operation for determining how to model or simulate the one or more models of physical systems is embedded in the initial application data structure. - Modeling operations that are contemplated, and that the data in a multiphysics model data structure may represent, include such operations as defining model parameters, functions, variables, variable expressions, operators, physical properties, physical quantities, and/or material properties for modeling the physical system(s). Additional modeling operation can include importing, building, and/or displaying a model geometry and/or mesh. Modeling operations can also include setting and/or displaying (a) domain physics settings and physics properties, (b) boundary conditions, (c) constraints, (d) loads, (e) setting initial values, and/or (f) setting initial conditions for modeling the physical system(s). Further aspects of modeling operations that are contemplated include computing numerical equations for the model of physical system or the exporting of data, results, result plots, geometry, mesh, images, animations, and reports for the modeling of the physical system(s). Additional modeling operations can also include displaying and evaluating results, result plots, and/or reports along with the clearing (e.g., removal) of solutions and meshes for the model of physical systems.
- The customized modeling created by the application builder wizard is in response to customized user inputs received via one or more new application window form(s) and one or more application features for the one or more new application window form(s).
FIG. 3 illustrates exemplary aspects of a method for generating a modified application data structure.FIGS. 4-8 illustrate exemplary graphical user interfaces for exemplary aspects of the method steps ofFIG. 3 , including (i) the creation of an initial application data structure, (ii) adding a new form to an application data structure, (iii) adding a button widget to a new form and linking the widget to a command sequence in an embedded model of a physical system, (iv) selecting a window layout and for adding additional new forms in an application data structure, and (v) adding an output form to an application data structure. - In some aspects, an application builder wizard for creating an application data structure includes any of a plurality of application features. The application builder wizard can include a plurality of different user-selectable forms as will be described in more detail below. For example, the application builder wizard can include an input form that may have one or more selectable child nodes associated with an application feature, and thus, in some aspects the application builder wizard is a system that provides user-selectable options from a plurality of ready-made templates associated with application features for modeling physical systems. The application builder wizard described in the context of, for example,
FIGS. 3 to 19 , is particularly useful and desirable because it provides a system that allows for the quick and efficient building and customizing an application data structure that can then be executed by a multiphysics modeling system. - In some aspects, a method for accessing settings for forming an application data structure in an application builder's graphical user interface is implemented using an application builder wizard that guides the user of an application builder software. The method may add user inputs, methods to run operations and simulation using the embedded multiphysics model, and outputs such as graphs, tables, and values based on the operations and multiphysics modeling simulation.
- In some aspects, a method interprets an application data structure and creates an application model in its own user interface or is embedded in a multiphysics software's user interface. The application running in its own user interface may access methods in a multiphysics modeling software, for example using a client-server connection. The method may load the application model data structure and process the execution sequence determined by this structure. The application model may be processed in a multiphysics modeling software to generate a multiphysics model data structure that can be used for running simulations.
- Referring now to
FIG. 3 , a flowchart illustrates exemplary aspects of a method for creating or generating a modified application data structure. Select acts implemented as part of the method may be available through a graphical user interface in an application interface builder system, such as a modified version of the systems described in U.S. Patent Publication No. 2014/0047407, published on Feb. 13, 2014, entitled, “Systems and Methods for Creating Application Interfaces for Forming and Solving Problems in a Modeling System”, which is incorporated by reference herein in its entirety, or the Application Builder available from COMSOL in the COMSOL Multiphysics® Version 4.4 product along with later versions. When the method illustrated byFIG. 3 is executed, the resulting application data structure can be particularly useful when applied to generate a customized application (e.g., a customized application that models and simulates a physical system) that accesses methods of a multiphysics modeling system, such as the methods from COMSOL Multiphysics® Version 4.4 (along with later and earlier versions), available from COMSOL, Inc. of Burlington, Mass., USA, and the multiphysics modeling systems described in U.S. Pat. No. 7,596,474, issued Sep. 29, 2009, and U.S. Pat. No. 8,626,475, issued Jan. 7, 2014. - The exemplary method of
FIG. 3 may be useful for different applications of modeling and simulation of physical systems, such as the modeling and simulation of specific types of physical systems including an electric motor, a fuel cell stack, a loudspeaker, a waveguide, a mixer for fine chemicals and food industries, a multi-tube heat exchanger, a plasma reactor, a semiconductor wafer, and/or a pressurized pipe system, which are just a few of many examples to which the processes and systems disclosed herein can be applied to provide useful results. The generated customized application data structure created from the execution of the method ofFIG. 3 accesses methods in the multiphysics modeling system for controlling selected settings in a multiphysics model and for running simulations within the multiphysics modeling system. - Beginning at
step 100 a, a multiphysics model can be either created or selected with the corresponding multiphysicsmodel data structure 100 b being loaded into a memory associated with the model processing unit(s) of the system executing the application builder wizard. Next, atstep 100 c, in some aspects of the application builder wizard, the multiphysics model data structure is embedded as an embedded model in an initialapplication data structure 100 d. Then, atstep 100 e, a main window containing a single window form (or a plurality of window forms in some aspects) is automatically added as window form data to the application data structure, where other forms and widgets may be included using an application interface builder module. In some aspects, it is contemplated that the embedded multiphysics model data structure includes a geometry subroutine and a call to a geometry subroutine in a geometry sequence. - The acts at steps 100 a-100 e can be implemented by saving a multiphysics model onto a memory device as an application file and results in the creation of an initial application data structure with a corresponding embedded model and main window. It is also contemplated that an application interface builder system can include an option to select a new application and provide a list of multiphysics models that can be saved as applications.
- Next, at
steps - An input form can include a widget or a collection of widgets that listen to or monitor for different user actions when an application is executed. An application interface builder module can include predefined template forms (or form features), form collections (or form collection features), and widget collections to be used in, for example, application windows whose layout and functionality are being determined for a customized application. It is also contemplated that an input form (or input widget) that can be added in
step - After an input form is added at
step 200 a, a user can select to finish modifications to the customized application data structure at which point the process proceeds to step 500 where the application data structure is outputted and may be stored in a memory device for subsequent execution. The user can also opt to add additional input forms by returning to step 200 or to proceed to add command sequences and widgets atstep 300. - At
steps - Modeling operations in the embedded multiphysics model data structure (e.g., step 100 c) can be linked to a widget, widget collections, form features, or form collection features described herein. For example, a widget linked to a command sequence can implement modeling operations, such as defining model parameters, functions, variables, variable expressions, operators, physical properties, physical quantities, and/or material properties for a customized modeling of physical system(s). A widget can also be linked to a command sequence for importing, building, and/or displaying a model geometry and/or mesh. Other command sequences linked to a widget for modeling operations can also include setting and/or displaying domain physics settings and physics properties, boundary conditions, constraints, loads, setting initial values, and/or setting or defining initial conditions for a customized modeling of the physical system(s). Further aspects of modeling operations for which a command sequence can be linked to a widget include computing numerical equations for the model of physical system or the exporting of data, results, result plots, geometry, mesh, images, animations, and/or reports for a customized modeling of the physical system(s). Additional aspects of modeling operation for which a command sequence can be linked to a widget include displaying and evaluating results, result plots, and/or reports along with the clearing (e.g., removal) of solutions and meshes for the model of physical systems. The application builder wizard graphical user interface(s) are applied to receive the user inputs for the desired linking of added widget(s) to command sequence(s) for the desired modeling operation(s).
- It is contemplated that a command sequence can also be selected, together with a widget or an input form, from a list of selectable command options (e.g., various modeling operations) in the embedded model and in the application data structure. The command options that are selected can then form a command sequence, which may then be linked to the selected widget or input form. The widget that executes a command sequence can be placed in an existing form, for example in an input form created previously, or in a newly created input form.
- After a command sequence and widget is added at
step 300 a, a user can select to finish modifications to the customized application data structure at which point the process proceeds to step 500 where the application data structure is outputted and may be stored in a memory device for subsequent execution. The user can also opt to add additional command sequences and widgets by returning to step 300 or to proceed to add output form(s) atstep 400. - At
steps - As illustrated in
FIG. 3 and described herein, steps 200, 300, and 400 may be repeated in order to add several application features, such as input forms, command sequences, and output forms, in creating or modifying an application data structure. In some aspects, each of the method steps described above may be followed by an option for closing the application builder wizard by selecting “done” in each of theoptions FIG. 21 , a form collection created by an application builder wizard is illustrated aselement 1410 or the “Single Window Form”, and include member forms such asinput form 1430 and the “Compute” widget. The “Results” form would be considered a pure form. - In some aspects, it is contemplated that an application data structure generated by the application builder wizard system may be used directly for running an application; either in its own application user interface or as an application embedded in a multiphysics software. In addition, this application data structure may be extended in the main user interface (outside of the application builder wizard) in an application interface builder system in order to include new forms, widgets, events, declarations, and methods.
- Referring now to
FIG. 4 , an exemplary aspect of graphical user interfaces are illustrated for a method step of creating an initial application data structure.FIG. 4 includes examples from a modeling system of afile menu 101 a, adialog page 101 c for creating a new application, and alist 101 e of multiphysics models where a user of a multiphysics modeling system may store a multiphysics model as an application. The display of the illustrated exemplary user interfaces and the selections therefrom are contemplated to be steps for creating an initial application data structure, the execution of which is illustrated instep 102 that results in the output of anapplication data structure 102 a. The user interface and steps illustrated inFIG. 4 represent one or more of the steps 100 a-100 e fromFIG. 3 . - In some aspects, a user of a multiphysics modeling system may select the menu item “save as application” 101 b, which may display the
progress window 102 for the creating and outputting the initialapplication data structure 102 a from an already open multiphysics model. - It is also contemplated that a user of an application interface builder system may create a new application by selecting the
Application Builder indicia 101 d, which can cause the display of a list of multiphysics models which may be divided into various model libraries of selectable models, such as a mixer model library, a MEMS model library, microfluidics module library, a pipe flow model library, or other model libraries. Such models may be selected 101 f and saved as applications, which is followed by the display of theprogress window 102 for creating and outputting an initialapplication data structure 102 a. - As mentioned previously, the initial application data structure created in 102 may also include a main window with a window form for adding forms (and/or form features) and widgets to the application data structure for creating an application in an application interface builder system. Upon completion of the methods illustrated in
FIG. 4 , an application builder wizard is be executed in some aspects to guide the user of an application interface builder system through the method steps for adding application features, such as forms (and/or form features), widgets, events, declarations, methods, and other components to an initial application data structure to generate a modified application data structure. The user can be guided through the steps described inFIG. 3 along with the exemplary aspects illustrated herein, for example, beginning withFIG. 5 . - Referring now to
FIG. 5 , a graphical user interface for an applicationbuilder wizard window 201 is illustrated for one exemplary addition of an application feature, such as adding a new form to an application data structure. The GUI provides an exemplary aspect of an input form (see, e.g.,elements FIG. 3 ) that can be created by the process of generating of an application data structure that is described in more detail inFIG. 3 . The input form can include an input field widget that is linked to a parameter, such as in an embedded multiphysics model data structure for the mixer model selected previously inFIG. 4 . The title of the input form may be entered in a formtitle text box 202. A parameter, for example the impeller diameter (e.g., 203), may be selected from a list of available inputs and outputs. The list of inputs and outputs is available in the embedded multiphysics model and, in some aspects, may be represented by the embedded model's model tree. Following auser selection 204 of a parameter, the new form page may be updated with the selectedparameter 205 from the list of selected inputs (or outputs), and a preview of the input field widget and its associated label and unit label (e.g., 206) that is linked to the parameter may be displayed to the user as a preview, for instance in a preview section of thewindow 201 or in a separate preview window. The input field widget and its associated label and unit label collectively represent an example of a widget collection. The preview shows the user what the new form may look like when the application data structure that is being created via the application builder wizard is executed. - It is contemplated that a new form created in the method step above does not have to be a “pure” input or output form. A new form that is added to an application data structure can also contain input forms, output forms, input widgets, and output widgets as constituents of the new form. For example, in some aspects, an alternative act after adding a text field widget may be to add a plot linked to a graphics widget (e.g., see
elements - Referring now to
FIG. 6 , a graphical user interface is illustrated for another exemplary addition of an application feature, such as adding a button widget to a new form and linking the widget to a command sequence in an embedded multiphysics model of a physical system. The GUI provides an exemplary aspect of adding a command sequence and widget (see, e.g.,elements FIG. 3 ) that can be created by the process of generating of an application data structure described forFIG. 3 . In the exemplary new form illustrated inFIG. 6 , a user selection of thebutton tab 301 can cause a list of commands to be displayed that may be added to a command sequence. The list can be dependent on commands available in the embedded multiphysics model. In one exemplary aspect, a “compute study”command 302, for running the multiphysics model that is embedded in the application data structure, may be selected 303 and linked to a button widget. Thecommand 302 and link to the button widget are then added to the new form entitled “model inputs” in theform title box 304. This user-selectedcommand sequence 305 along with a preview of the new form, now also including a “compute”button widget 306, can then be displayed to the user in the application builder wizard. Furthermore, in some aspect, the application builder wizard further includes awindow layout button 307, that upon selection by a user, may show alternatives for how the new form should be displayed in the window form when the application data structure is executed. - Referring now to
FIG. 7 , another graphical user interface is illustrated for selecting a window layout and for adding additional new forms in an application data structure according to aspects of a method for creating an application. In the exemplary GUI, a user can select for the new form, “Model Inputs”, options that alter the window layout for the exemplary application being built using the wizard. Furthermore, a user-selectable button 311 allows the user to create additional new forms in an application data structure. The GUI for selecting window layout options can include an application builder tree representation of previously created window forms 309, 310 (e.g., “Single Window Form” in element 503 ofFIG. 8 ; “Model Inputs” inelement 202 ofFIG. 5 ). It is also contemplated that the GUI for selecting window layout options for an application data structure can include acombo box 308 for selecting the form separator around the created form, such as a border or title bar. - In some aspects, a user selection of the “create new form”
button 311 in the window layout application builder wizard GUI may create an additional new form, for example an output form (seesteps FIG. 3 ). As discussed for the previous new form inFIGS. 5 and 6, a title for the second new form may be entered in the form title text box 401 (e.g., the title “results”). In further exemplary aspects of the new forms that may be added to an application data structure through the application builder wizard, a user may select aplots tab 402 and further select aplot group 403 from the results tree in the embedded multiphysics model (e.g., a “velocity” plot group in the mixer model). Next, by selecting anarrow button 404, the user can then add to the new form (e.g., the “results” form) a graphics widget linked to the selectedplot group 403. - Referring now to
FIG. 8 , a graphical user interface is illustrated for another exemplary addition of an application feature, such as adding an output form to an application data structure according to aspects of a method for creating an application. As generally discussed above, a new form that is added can include other input forms, output forms, input widgets, and output widgets as constituents of the form. So, for example, a form does not have to be a pure output form and instead can include other constituents. In the exemplary aspect of a selected graphics widget linked to thevelocity plot group 405 in the embedded mixer model illustrated in the GUI ofFIG. 7 , apreview 406 can be displayed in a new page for the output form. By a user then selecting on the “done”icon 407, the created output form is added to the application data structure and may also open amain user interface 501 in an application builder system using the application data structure that would have been created, such as instep 500 ofFIG. 3 . - It is contemplated that in some aspects, a user interface of an application builder system may include an application builder tree representing the initial application data structure and the operations that create a modified application data structure. For example, the
main window 502 added in previous method steps ofFIG. 3 (seestep 100 e) is shown in themain user interface 501 as a node together with a plurality of child nodes. In addition, the single window form 503, created together with the main window, contains two child nodes representing form references 504 to the two forms created in the application builder wizard. - The first exemplary form created with the application builder wizard, above in
FIGS. 5 and 6 , was the “Model Inputs” form 505 (see 201), which is represented by a node that includes child nodes for the label 506, the input field widget 507 for inputting the impeller diameter value, theunit label 508, and thebutton 509 for computing the command sequence for the study. The second exemplary form created with the application builder wizard, above inFIGS. 7 and 8 , is the “Results” form 510, which includes thegraphics widget 511 that displays the selected plot group when the application is executed. The “Methods”node 512 includes child nodes for thecommand sequence 513, which computes the study and updates the plot when the application is executed. - It is contemplated that each of the nodes in the application builder tree may include corresponding settings for the forms, events, declarations, and methods and their respective child nodes. Each of the nodes in the application builder tree may represent constituents and operations that may define an application in an application builder system.
-
FIGS. 8-18 illustrate exemplary aspects of an application builder system (e.g., Application Builder available from COMSOL) that includes an application data structure as created by the application builder wizard described above in the context ofFIGS. 3-8 . The application data structure created through the application builder wizard can be further defined and used in the application builder system, for further defining the new form(s) (and/or form features), command sequence(s), and widget(s) templates created with the application builder wizard. - The generated application data structure(s) can be used to provide a customized modeling of physical system(s) based on one or more modeling operations, one or more geometries of the model(s) of the physical system(s), and one or more application features, all defined in the application data structure that further includes a multiphysics model embedded therein.
- Referring now to
FIG. 9 , a graphical user interface is illustrated for an exemplary settings window for editing settings for a main window (e.g., similar to main window 501) of an application according to aspects of a method for creating an application. Amain window node 514 can include acorresponding settings window 515, which is shown in a settings window position in the application builder systems user interface when the corresponding node is selected in the application builder tree. The settings window can include atitle text box 516 and anicon text box 517 where the name and path of an icon image file may be entered by the user of an application builder system. The title may be shown in the window bar and the icon image may be show in the corner of the widow frame when the application is executed. - It is contemplated that the main window node can include a static
window child node 518 which may refer to the single window form. Several window references may be created as child nodes to the window layout node in order to create an application that contains several windows. In such case, several window forms may be created as child nodes to the forms-node instead of the single window form. Adding several windows in an application may allow for the detaching and reattaching of application windows when the application is executed. - Referring now to
FIG. 10 , a graphical user interface is illustrated for anexemplary settings window 521 for astatic window node 520 according to aspects of a method for creating an application. Thesettings window 521 can include a reference that links to a window form, for example thesingle window form 522, which may refer to thecorresponding node 523. Apreferences section 524 may allow settings such as showing the linked window when the application is started and hiding or showing the title of the linked window when the application is executed. - Referring now to
FIG. 11 , a graphical user interface is illustrated for an exemplary single windowform settings window 526 for a single window form node 525 (e.g., a window form) according to aspects of a method for creating an application. It is contemplated that a single window form can be created that includes other forms and widgets as a member or as reference(s) to other form(s). For example, thesettings window 526 includes a title and an icon image reference, adialog settings section 527 for defining an initial size, asection settings 528 for defining if the member section forms of the form should be expandable or initially collapsed, agrid layout section 529 for the positioning of the widgets that may be contained in the form, and anappearance section 530 for determining the foreground and background colors of the form. In this example, the single window form contains twoexemplary references 531 to two member forms, the “model inputs” form and the “results” form. -
FIG. 12 illustrates a graphical user interface for an exemplaryform settings window 533 for aform reference 532 according to aspects of a method for creating an application. A settings window (e.g., 533) for a form reference (e.g.,node 532 referring to “FormReference 1”) can include a reference combo box (e.g., 534) for selecting a linked form from a list of selectable forms. Forexample combo box 534 illustrates a linked form that is the model inputs form 536. The model inputs form 536 can also include the same settings as the single window form described above forFIG. 11 . The model inputs form 536 can further include widgets for the label (e.g., 537), the input field (e.g., 538), and the unit label (e.g., 539), that were created in the previous method steps (e.g., 204, 205, and 206) described in the context ofFIG. 5 . The model inputs form 536 can also include the button widget (e.g., 540) created in the previous steps (e.g., 303, 304, 305, and 306) described in the context ofFIG. 6 . - Additional details for exemplary aspects of the label, input field, unit label, and button widget are described in the context of
FIGS. 13-16 . - Referring now to
FIG. 13 , a graphical user interface is illustrated for an exemplarylabel settings window 542 for a label widget 541 according to aspects of a method for creating an application. Thelabel text 543 can be entered manually or derived from the description in the linked parameter in the embedded multiphysics model (see, e.g., previous method steps 204, 205, and 206 inFIG. 5 ). - Referring now to
FIG. 14 , a graphical user interface is illustrated for an exemplary inputfield settings window 547 for aninput field widget 546 according to aspects of a method for creating an application. It is contemplated that the input field node can include a reference to a linked selected data source in the embeddedmultiphysics model 549, which may be a parameter or a variable in the embedded model selected from a replica of the parameter and variable branches in the model tree (e.g., element 548). A data source settings section 550 of thesettings window 547 can also include settings for unit labels, which may be linked to a unit label node along with a default values text box, which may derive its value from the parameter or variable list from the embedded model. - Referring now to
FIG. 15 , a graphical user interface is illustrated for an exemplary unitlabel settings window 552 for a unit label widget according to aspects of a method for creating an application. Theunit label node 551 can be linked to an input field widget (e.g., element 550 inFIG. 14 ). The unit in the unit label can be manually selected from a list ofphysical quantities 553 and may also update a unit text box 554 (e.g., SI unit text box). - Referring now to
FIG. 16 , a graphical user interface is illustrated for an exemplary button settings window 556 for a button widget 555 according to aspects of a method for creating an application. The button widget settings can include a reference to a method that is selected from a list of available methods 557. In the illustrated exemplary aspect, a command sequence method reference 559 was selected that implements a simulation of the mixer and plots the velocity field when the button is selected during the execution of the application. - Referring now to
FIG. 17 , a graphical user interface is illustrated for an exemplarygraphics settings window 561 for agraphics widget 560 of an application according to aspects of a method for creating an application data structure. The displayed graphics settings window can include a replica of the geometries, mesh, and results branches of the model tree (e.g., element 562) of the embedded model. Furthermore, the graphics settings window can also be linked to thegraphics widget 560 as the source for the output. In the displayed exemplary aspect, the selectedsource 563 is a velocity plot group that may show the flow pattern in the exemplary mixer discussed throughout the present disclosure. Thegraphics settings 564 can allow for a selection of a logo positioned in a corner of the graphics window and a background color, which may be shown when the application defined in the application data structure is executed. - Referring now to
FIG. 18 , a graphical user interface is illustrated for an exemplary commandsequence settings window 566 for acommand sequence method 565 of an application according to aspects of a method for creating an application data structure. The command sequence can include a label setting 567 (e.g., “Compute Study 1”) , a name setting (e.g., “Compute Study 1”), an icon setting (e.g., “study.png”), and size settings (e.g., “Medium”). Commands can be added to a command sequence through user selections of commands displayed from a replica of the embedded multiphysics model's model tree (e.g., see element 568). The sequence of commands can be inspected from a displayed sequence list. For example, the exemplary commandsequence settings window 566 includes a command for implementing a study 569 (e.g., “/Study 1”) and a command that plots the velocity field plot group 570 (e.g., /Results/Velocity (rmspf)”). The command sequence can be implemented by a widget, such as a displayed user-selectable button that is linked to the command sequence (see, e.g.,FIG. 16 ). Selection of the button during execution of the application implements the command sequence. - As discussed previously, it is contemplated that an application data structure generated using the described aspects of an application builder wizard can be extended to a main user interface (i.e., outside of the application builder wizard) of an application builder system to allow the creation or addition of new windows, forms, events, declarations, and methods.
- Referring now to
FIG. 19 , a flowchart illustrates exemplary aspects of a method for modifying an initial application data structure. The initial application data structure can be created using the application builder wizard. It is also contemplated that the initial application data structure may have been previously created by saving a multiphysics model as an application onto a memory device. The method steps described forFIG. 19 can be accessed as user-selectable options on a user interface in an application builder system. Follow execution of the method steps, the resulting application data structure generates a customized application that accesses methods in a multiphysics modeling system for controlling selected settings in a multiphysics model and implements simulations in the multiphysics modeling system. - At
step 500 a, the initial application data structure that a user of the application builder system wishes to extend is created or loaded into the application builder system. Following the creation or loading of the initial application data structure, an application builder tree and a preview of the application may be displayed in the user interface for the application builder system. In some aspects, the preview provides a display of how the application user interface is displayed to the user when the application is executed. - Next, at
step 600, a static window or a window panel is added to an already available main window or desktop window. In some aspects, a main window, or desktop window, is a specific type of form that defines one or several frames in a computer desktop where other forms may be displayed when an application is executed. An example of a main window is illustrated inFIG. 9 aselement 515. A main window can be created automatically by an application builder system when a model is saved as an application, and in some aspects, the main window may already be available in theapplication data structure 500 b used to create the initial application data structure. A static window can define one frame in a main window, or desktop window, where other forms and widgets are positioned in rows and columns. An example of a static window is illustrated inFIG. 10 aselement 521. The member forms and widgets can be positioned by reference. A static window may be the default window for an application that only includes one window inside the main window or desktop window. Such a window may not be resized or detached. A static window can be created automatically by an application builder system when a model is saved as an application, and in some aspects, may already be available be in theapplication data structure 500 b. A window panel can define one frame in a main window, or desktop window, where other forms and widgets may be positioned in rows and columns. The difference compared to the static window may be that windows positioned in a window panel may be detached and resized. The member forms and widgets in a window panel may be positioned by reference, where the member forms and widgets may be linked to the window panel. - Next, at
step 700, a menu is added to the application data structure according to some aspects. A main menu may be another type of available form in an application builder system that can include references to widgets. A menu may be accessed in a toolbar in a main window or in a desktop window when the application is executed. A menu may also be a tabbed toolbar menu (e.g., a ribbon menu by Microsoft® which may show when the application is executed on a Windows® system). A main menu can include actions as child nodes that may be linked to command sequences and methods and to widgets, such as a button, which may execute the action when selected by a user during execution of the application. - Next, at
step 800, a form can be added to an application data structure. A form can include a collection of member forms and widgets to achieve a desired layout for an application's user interface. Members in a form can be added by reference to input and output forms or by directly adding input forms, output forms, and widgets as child nodes to the parent form. Several types of forms may be available in an application builder system. For example, a window form is a form that includes other forms and widgets as member forms. The member forms and widgets can be linked to the window form or they can be child nodes to the window form in the application builder tree. A window form may be linked to a static window or to a window panel to get a specific position in a main window or desktop when the application is executed. - Next, in
step 900, a widget can be added to the application data structure. A widget can be a member widget in a windows form or panel form. An application builder system can include a number of basic widgets that may be combined in different forms. Basic widgets may be an input field (e.g., seeelement 546 fromFIG. 14 ), a combo box, a check box, a button (e.g., see element 555 fromFIG. 16 ), or data display widgets. These basic widgets can be combined with label widgets. Label widgets can include a pure label widget (e.g., element 541 fromFIG. 13 ), a unit label (e.g.,element 551 fromFIG. 15 ) that can be entered manually or linked to a unit of a physical quantity, or an equation label that can receive equation inputs in the form of mathematical typesetting formats, such as TeX and LaTeX. It is also contemplated that an application builder system can include graphics widgets (e.g., seeelement 560 fromFIG. 17 ) along with image widgets to output images in an image format from a graphics display. - An application builder system can also include a number of list widgets, such as list box, radio button, and table widgets. A list box is a widget that accepts a number of values for an input shown in a drop-down list. It can be used to select from a number of fixed predefined options for setting in the embedded model when the application is executed. A list box can also be linked to an event that may hide or show different forms depending on the option selected by a user when the application is executed. A radio buttons list can present a fixed number of options for an input where only one option may be selected at the time. A radio button may be used to select options in an embedded model when the application is executed. A table widget is a widget designed to accept a number of inputs in rows and columns when the application is executed. These inputs can be linked to parameters, variables, and operations in the embedded model.
- It is further contemplated that an application builder system can include panels where other member widgets are positioned. Such panels can be grid, form reference, section form, tabbed pane, or card stack panels. A grid panel can position a number of widgets in a grid structure with rows and columns. A form reference panel may create a link to another form and may also determine the position and size of a linked form (e.g., see
element 532 fromFIG. 12 ). A section form panel can be used to divide a window form into several sections. Such a section form panel may have a heading bar containing for example a description and the member forms placed beneath the bar. The member forms may be linked using a list of available forms in an application builder system. A tabbed panel can arrange several other forms and panels into one new form. In some aspects, several forms can be displayed above each other in a desktop window or settings window. Such forms may be selected using tabs when an application is executed. The member forms may be linked using a list of available forms in an application builder system. A card stack panel can include a number of predefined forms that may be shown depending on the selection made by a user when the application is executed. Only one member of the forms that is member in a card stack may be active at a given time when an application containing such a form collection is executed. Controlling which of the forms in a card stack that may be displayed can be accomplished using events, which are described in more detail below in the context ofstep 1000. The member forms can be linked using a list of available forms in an application builder system. - In some aspects of an application builder system, ready-made forms are included for specific purposes. The ready-made forms can include other forms and widgets. Examples of such form collections can include text forms, which may combine input field and labels; vectors forms for vector inputs; data display forms, which may combine data displays and labels; combo box forms, including combo box and labels; selection forms; and coordinate picker forms. Other more specific forms and widgets can include a progress bar, a slider, a toolbar, a dialog button form, or a filler widget. A selection form can allow linking a graphical input—completed by selecting domains, boundaries, edges, and points when the application is executed—to a selection defined in the embedded model. For example, a selection defined as an impeller surface can be used as input for a rotating wall boundary condition in the embedded model. The impeller surface selection list can be populated manually by a user of the application, thus getting the appropriate boundary conditions linked automatically for an arbitrary impeller geometry. The selection input widget thus allows for setting domain equations and boundary conditions, defined in the embedded model, using arbitrary geometries when the application is executed. A coordinate picker widget can receive graphical inputs from an application user clicking or providing selections on the graphics canvas causing an output of a string array including the coordinates for the clicked or selected points. The string data output can be used as inputs into other widgets and forms that may be linked to settings in the embedded model. A progress bar widget can receive a value from a parameter or variable used in a parametric sweep in the embedded model and output the progress of the model simulation, when the application is executed, based on the total number of variable values. A slider is an input widget that receives the value of a parameter (e.g., a parameter in the embedded model). A filler widget can be used to define an area in a form, with a specified size and background color, where no other forms may be shown during the execution of the application. The widget is used to align widgets and empty parts of a window or form during the execution of the application.
- The method for modifying an application data structure described in
FIG. 19 , next proceeds to step 1000, where an event can be added to the application data structure. An event can specify a logical condition that checks the value of an input declaration. For an input or an output form, such condition determines if the form will be enabled or disabled in the form window when the application is executed. A disabled form can either be hidden from the window or just grayed-out. - Next, at
step 1100, a declaration can be added to an application data structure. Declarations can declare data fields that cannot be changed by a user when the application is executed. Instead the data fields are used for reading values from the application or embedded model. For example, a data field may obtain its value indirectly, based on a selection received from the user in an input widget, such as a combo box or radio button. Such data field value(s) are then used in an if-statement that may show different options depending on the value during execution of the application. An output data field may be used for displaying the result from an evaluation in the embedded model during application execution. - Next, at
step 1200, a method can be added to an application data structure. A method defines a command sequence of operations and may be executed from an input form, for example, when a button is selected by a system user, during the execution of an application. A command sequence can include an update of an output form, for example an update of a plot in the embedded model, which may then generate a new plot in a graphics window in an application, for example using a canvas window. It is also contemplated that a method can include code snippet(s) (e.g., subroutines including limited instructions for specific tasks) that when executed, during the implementation of the application, control and run commands that control forms, widgets, events, declarations, or commands defined in the application data structure and in the embedded model. - Then, at
step 1300, the modified application data structure is generated as output from the above described methods beginning withstep 500 and continuing through one or more ofsteps FIG. 19 can be implemented in any order and that the steps can be repeated by the system user until the desired application design is achieved that allows for the customized modeling of physical systems on a multiphysics modeling system. - It is contemplated that at every
step application data structure 500 b (that is initially created instep 500 a) can be updated, as well, into a modified application data structure. If no additions are made insteps step 1300 will be the same as theapplication data structure 500 b. - It is further contemplated that the generated application data structure can include the multiphysics model data structure as an embedded model, from the model that the application is based upon, together with a hierarchy that represent the nodes generated by the method steps described for
FIG. 19 . Furthermore, the deployment step of a finalized application data structure can also include storing the finalized application data structure in a new or in an existing library. A library can represent a real folder structure on a file system, or in a network. Any of the existing libraries can be accessed by the systems that create a multiphysics model data structure based on an application data structure. - Referring now to
FIG. 20 , an exemplary unified modeling language (UML) object diagram is illustrated of instance level relationships between components according to one aspect of an application data structure created by the method described earlier forFIG. 3 .FIG. 20 illustrates an end result or the outputted application data structure created through the application builder wizard.FIG. 20 also provides a schematic or object diagram of the relationships between the features illustrated inFIGS. 9-18 , and thus, it is contemplated thatFIG. 20 can also provide a schematic of the data structure for the application builder. - As illustrated in the object diagram of
FIG. 20 , an application data structure includes at least one embeddedmodel 500 c and at least one main window ordesktop 500 d. An application data structure can further include at least oneform collection 601, such as a static window or window panel that may include a menu, which can also be considered a form collection. An application data structure can further include one or several forms (and/or form features), such as input forms andwidgets 801, andinput declarations 1101, which may be linked with acorresponding event 1001. An application data structure can also include output forms orwidgets 802 along with anywhere from zero orseveral output declarations 1102 that in some aspect include acorresponding event 1002. Anywhere from zero toseveral methods 1201 are contemplated that may be included in an application data structure along with a corresponding event 1003. Forms, widgets, events, and methods may be linked with parameters, variables, operations, and settings in the embeddedmodel 500 c. - Referring now to
FIG. 21 , agraphical user interface 1400 is illustrated that is a form editor for creating input forms, output forms, and form collections according to aspects of a method for creating an application data structure. The illustratedgraphical user interface 1400 is the output of an exemplary application data structure created with the application builder wizard and viewed through the form editor of an application builder system. Thegraphical user interface 1400 provides for interactive drawing and positioning offorms labels input fields - A
toolbar 1440 can also include buttons and controls for showing and adding forms and widgets. There may also be an alternative to add forms and widgets in the application builder tree by right-clicking a node and selecting from a context menu. When a form or widget node is selected in the application builder tree, such as aninput field 1431, itslayout 1430 may be shown in agraphics builder window 1401 allowing for user positioning in the corresponding form or widget collection interactively. An additional layout section may also be shown in thesettings window 1450 for widget and form features. In this layout section the values for the layout information may be set; for example, position, width, and height of a form or widget. These values may be updated automatically with interactive changes in the graphics builder window. - A
graphics builder window 1401 provides a preview of an application in the application builder system when the application is executed. Thus, what is previewed inwindow 1401 is what a user of an application will see upon execution of the application that is created in the application builder system, which in this case was also created using the application builder wizard. - In some aspects, relative positioning may be used where, for example, a first form or widget may be placed freely on a form collection while other forms and widgets are then typically placed relative to the first form or widget with the aid of horizontal and vertical snapping. Vertical snapping and horizontal snapping may be mutually independent, and each form or widget may contribute with several vertical and horizontal snapping lines. All forms or widgets can contribute with a horizontal snapping line along their left edge. Forms or widgets with a fixed width, such as buttons, combo boxes, and text boxes, may contribute with a horizontal snapping line also along their right edge.
- There may also be a row spacing that can be specified as a preference for the graphics builder window and that may typically have a default value of about five pixels. The row spacing may specify how much empty space there should be from the bottom of one form or widget to the top of the next. It may be used to decide where to position the form or widget on the row immediately below an existing form or widget. This row spacing may contribute with vertical snapping lines above and below a form or widget, making it easy to start a new row of forms or widgets above or below existing widgets.
- When a user of the application builder system moves and resizes widgets, the snapping may try to align the left edge of the widget with the left edge of other widgets or the right edge of the widget with the right edge of other widgets and similarly in the vertical direction. While moving or resizing a widget, vertical and/or horizontal snapping lines may be drawn in the graphics builder window when snapping occurs. The snapping hot zone may be about 6-7 pixels in each direction of the snapping line so even though snapping is on it is possible to place the form or widget freely by positioning it outside the hot zone of any snapping line.
- A form or a widget may be selected in the graphics builder window by clicking on them. Several forms or widgets may be selected by pressing the Ctrl key while clicking Clicking on an already selected form or widget, while pressing the Ctrl key, may toggle the selection. There may also be a box selection tool that allows the user of the application builder to select several widgets by enclosing them with a rectangle. When a widget is selected, a highlight rectangle with some resize handles may be drawn around it 1410. By clicking and dragging in the interior of the widget it may be possible to move the widget. Horizontal and vertical snapping to other widgets in the form may be available both when moving and resizing widgets.
- There may be a two-way synchronization between the selection in the application tree and in the graphics builder window. If a form or widget node is selected in the application tree (1431), the corresponding form or widget may be selected in the graphics builder window (1430) and vice versa. Since multiple forms and widgets may be selected in the graphics builder window but only one set of settings for one form or widget can be shown in the settings window at the time, controls for changing width and height may also be available on the toolbar. When multiple forms or widgets are selected there may also be toolbar buttons for the following operations: Aligning the left, right, top, bottom, or center of the selected forms or widgets; distributing the widgets with equal spacing horizontally or vertically; and giving the widgets equal width or height. It may also be possible to change the text displayed on labels, check boxes, buttons, and so on by double-clicking on the form or widget in the graphics builder window and then just entering the new text inline within the form or widget. Copy and paste may also be available to be able to easily reuse form and widget configurations in another form collection.
- The graphics builder window may also have an automatic row and column creation. At each unique left border of a form or widget a new column may start and at each unique top border a new row may start. Because of the snapping used when drawing the forms and widgets, rather few rows and columns need to be created. Based on the width and height of a form or widget it may also be allowed to span several rows and columns. If several forms or widgets in a column have the same width as the form or widget with the maximum width in the column, these forms and widgets may be set to fill the column. This may be useful for getting several text boxes and combo boxes in a column with a straight right edge. The automatically created rows and columns may also be individual elements in the graphics builder window (1401), which can be selected by entering a grid layout mode by clicking the corresponding button in the toolbar (1460). A selected row may then be moved interactively up and down the other rows. For a selected column, a user of the application builder may then specify a fixed width or that the width should adapt to the width of the top level form if this is resized. There may also be tools such as insert row and delete row to easily make room for a new row or delete all forms or widgets in a row and compact the layout accordingly.
- A form and a widget collection may contain many forms and widgets and the grid layout may become fairly complex as new forms and widgets are added to the form collection. In such cases, it may be convenient to divide the form collection into several form collections with individual layout management and then place these as child form collections in the original form. In such cases, it may be possible to enclose a couple of forms and widgets in a form collection using a rectangle and then use an extract toolbar button (1470) to specify that those forms and widgets should be extracted to their own form collection.
-
FIG. 22 illustrates an exemplary flowchart of method steps for interpreting an application data structure for generating and maintaining an application model tree, context menu, and settings window in a multiphysics modeling system. The interpretation method can further be applied to generate an application model data structure based on settings specified by a user of a multiphysics modeling system. Atstep 1300 a, a list of applications are determined and displayed from a set of availableapplication data structures 1300 b. Next, atstep 1400 a, a user can select an application from a displayed menu list, which then adds the application model to an applicationmodel data structure 1400 b. - The method then proceeds to the logical decision box where a decision is made to add or edit application model methods and setting. If the decision is negative, the application model data structure is finalized at
step 1700. If the decision is positive, the process proceeds to step 1500 a, where an application user interface including application model settings and methods is determined and displayed 1500 a based on the definition of application features available in theapplication data structure 1500 b. Next, atstep 1600 a, a system user can edit the application model settings and methods. The default settings and the changed setting are then stored in the modified applicationmodel data structure 1600 b. Then, if no more application model methods or settings are to be added or edited, the application model data structure is finalized instep 1700. - In a later method step, the application model data structure is then interpreted in a multiphysics modeling system that generates the simulation results for the model. These simulation results can be displayed in an output form.
- Referring now to
FIG. 23 , an exemplary flowchart is illustrated of method steps for interpreting an application model data structure and generating a multiphysics model data structure that includes a model object. The method illustrated is for the steps prior to discretizing and solving the equations in a multiphysics modeling system. Atstep 1800 a, an application model can be determined from an applicationmodel data structure 1800 b. Next, atstep 1900 a, the applicationmodel data structure 1900 b is loaded to the interpreter. Then, atstep 2000, execution sequences from the application model data structure are processed. Atsteps step 2003. When all execution sequences have been processed, a multiphysics model data structure may be generated atstep 2004. - According to certain aspects of the present disclosure, an Alternative Embodiment A is a system for generating a modified application data structure for modeling physical systems. The modified application data structure is generated from guided user inputs received through one or more application builder wizard graphical user interfaces. The system comprises one or more modeling system processing units, one or more user input devices, optionally a display device, and/or one or more memory devices. The one or more modeling processing units are adapted, during use, to embed a pre-determined or a user-selected multiphysics model data structure in an initial application data structure. The multiphysics model data structure comprises data representing one or more models of physical systems. Each model of a physical system represents physical phenomena and/or physical processes. The multiphysics model data structure further comprises data representing at least one modeling operation for determining how to model and/or simulate the one or more models of physical systems. One or more new window forms are defined. In response to defining the one or more new window forms, window form data representing the defined one or more new window forms is added to the initial application data structure. One or more selections for application features from one or more user-selectable application feature options displayed in one or more of the application builder wizard graphical user interfaces are received. In response to receiving the one or more selections, application feature data corresponding to the received one or more selections is added. The application feature data represents one or more application features for the one or more new window forms. The application feature data is added to the initial application data structure to create a modified application data structure that further includes the window form data. Each added application feature comprises one or more of (i) first data representing at least one widget included in at least one of the new window forms, (ii) second data representing at least one form feature included in at least one of the new window forms, and/or (iii) third data representing at least one command sequence initiated through the at least one widget included in at least one new window form. The at least one form feature comprises one or more fields for specifying input data and/or output data and/or presentation format of input and/or output data. A command sequence comprises data specifying a sequence of operations to be carried out when executing an application defined by the modified application data structure. The at least one widget is linked to the command sequence such that selection of the at least one widget, during execution of the application, is operable to initiate the command sequence. The command sequence includes execution of at least one operation for the one or more models of physical systems defined in the embedded multiphysics model data structure. A modified application data structure is generated and stored in the one or more memory devices. The generated modified application data structure provides, when executed, a customized modeling of the physical systems in response to customized user inputs received via the one or more new window forms and the one or more application features for the one or more new window forms.
- An Alternative Embodiment B includes the aspects of Alternative Embodiment A and further including that the one or more new window forms are defined based on the receipt of one or more new window selections from a list of one or more displayed user-selectable window form options.
- An Alternative Embodiment C includes the aspects of any one of the systems of Alternative Embodiments A or B and further includes that the at least one widget is a plurality of widgets defining a widget collection.
- An Alternative Embodiment D includes the aspects of any one of the systems of Alternative Embodiments A to C and further includes that the at least one widget comprises data specifying an input field linked to a parameter in the multiphysics model data structure embedded in the modified application data structure.
- An Alternative Embodiment E includes the aspects of any one of the systems of Alternative Embodiments A to D and further includes that the widget collection comprises an input field, the first data representing the input field, the first data further representing an input label and an input units label describing an expected user input for the input field.
- An Alternative Embodiment F includes the aspects of any one of the systems of Alternative Embodiments A to E and further includes that the widget collection, including the input field, the input label, and the input units label, is displayed in a preview in one of the one or more application builder wizard graphical user interfaces, the display occurring in response to one of the one or more selections including the at least one widget collection.
- An Alternative Embodiment G includes the aspects of any one of the systems of Alternative Embodiments A to F and further includes that a user selection is received for a modeling operation that sets an input parameter for modeling the physical systems, data representing the user selection for the modeling operation being included in the generated modified application data structure such that, when executed, provides a customized application for modeling the physical systems, the customized application including the selected modeling operation, the widget collection being linked to the modeling operation.
- An Alternative Embodiment H includes the aspects of any one of the systems of Alternative Embodiments A to G and further includes that the at least one form feature is a plurality of forms that define a form collection feature.
- An Alternative Embodiment I includes the aspects of any one of the systems of Alternative Embodiments A to H and further includes that the at least one form feature and the at least one widget are a combo box that displays a list of choices on a graphical user interface displaying one of the new window forms during execution of the generated modified application data structure, the list of choices corresponding to string data values.
- An Alternative Embodiment J includes the aspects of any one of the systems of Alternative Embodiments A to I and further includes that the at least one widget feature includes a check-box widget and/or a button widget.
- An Alternative Embodiment K includes the aspects of any one of the systems of Alternative Embodiments A to J and further includes that the at least one operation for the command sequence corresponds to a study to be applied to the one or more models defined in the embedded multiphysics model data structure.
- An Alternative Embodiment L includes the aspects of any one of the systems of Alternative Embodiments A to K and further includes that the at least one operation corresponds to an update to an output form that includes an update to a plot corresponding to simulation results for the one or more models defined in the embedded multiphysics model data structure, the update to the plot being in response to execution of a series of operations for the study.
- An Alternative Embodiment M includes the aspects of any one of the systems of Alternative Embodiments A to L and further includes that the at least one form feature, at least one widget, and/or the command sequence are added to the modified application data structure based on one or more received selections from one or more lists of user-selectable options displayed to a system user in the application builder wizard graphical user interface.
- An Alternative Embodiment N includes the aspects of any one of the systems of Alternative Embodiments A to M and further includes that the at least one form feature is an output form or an output form collection feature, the output form or output form collection feature including a graphics widget and/or a graphics widget collection linked to one of a plot group, a geometry, and/or a mesh for the one or more models in the embedded multiphysics model data structure.
- An Alternative Embodiment O includes the aspects of any one of the systems of Alternative Embodiments A to N and further includes that the graphics widget or graphics widget collection is configured to display data from an output declaration.
- An Alternative Embodiment P includes the aspects of any one of the systems of Alternative Embodiments A to O and further includes that the system user is guided in creating new application features, the guiding including displaying to the system user one or more first lists of modeling operations and/or sequences of operations available in the embedded multiphysics model data structure; and in response to receiving a user selection of one or more modeling operations or sequences of operations from the first lists, the selected operations being displayed to the system user in one or more second lists, the displayed second lists showing modeling operations or sequences of operations linked to at least one of the new application features.
- An Alternative Embodiment Q includes the aspects of any one of the systems of Alternative Embodiments A to P and further includes that the new application features include one or more of a new widget, widget collection, form feature, and/or form collection feature.
- An Alternative Embodiment R includes the aspects of any one of the systems of Alternative Embodiments A to Q and further includes that at least one of the first list or the second list includes a display of indicia representing that the selected modeling operations and/or sequences of operations are linked to an input widget or input widget collection, an output widget or output widget collection, a graphics widget or graphics widget collection, and/or a button widget or button widget collection.
- An Alternative Embodiment S includes the aspects of any one of the systems of Alternative Embodiments A to R and further includes that at least one of the one or more application builder wizard graphical user interfaces includes a preview displaying the new window form; and wherein in response to receiving the one or more selections, the preview is updated to display a representation of one or more of the added widgets or form features.
- An Alternative Embodiment T includes the aspects of any one of the systems of Alternative Embodiments A to S and further includes that the preview is updated to display a representation of the at least one widget in the new window form.
- An Alternative Embodiment U includes the aspects of any one of the systems of Alternative Embodiments A to T and further includes that the at least one widget is a graphics widget for displaying modeling results as plots, the preview being updated to display a representation of the graphics widget.
- An Alternative Embodiment V includes the aspects of any one of the systems of Alternative Embodiments A to U and further includes that the one or more application feature options comprise a plurality of user-selectable options for modeling operations, the plurality of user-selectable options including one or more of defining input parameters, defining material properties, defining functions, defining physical properties, defining physical quantities, defining operators, defining result settings, defining variables, defining variable expressions, defining study settings, defining boundary conditions, defining initial conditions, and/or defining initial values for the physical systems being modeled.
- An Alternative Embodiment W includes the aspects of any one of the systems of Alternative Embodiments A to V and further includes that the one or more application feature options comprise a plurality of user-selectable options for modeling operations, the plurality of user-selectable options including command sequences for one or more of building a geometry, displaying a geometry, building a mesh, displaying a mesh, computing numerical equations, displaying results, evaluating results, and/or plotting results.
- An Alternative Embodiment X includes the aspects of any one of the systems of Alternative Embodiments A to W and further includes that the plurality of user-selectable options includes displaying modeling results as plots.
- An Alternative Embodiment Y includes the aspects of any one of the systems of Alternative Embodiments A to X and further includes that the at least one widget is a button widget linked to a command sequence, the preview being updated to display a representation of the button widget linked to the command sequence.
- According to certain aspects of the present disclosure, an Alternative Embodiment Z is a computer-implemented method for generating a modified application data structure for modeling physical systems. The modified application data structure is generated from guided user inputs received through one or more graphical user interfaces customized using an application builder wizard. The method comprises embedding, via one or more modeling system processing units, a pre-determined or user-selected multiphysics model data structure in an initial application data structure. The multiphysics model data structure comprises data representing one or more models of physical systems. Each model of a physical system representing physical phenomena and/or physical processes. The multiphysics model data structure further comprising data representing at least one modeling operation for determining how to model or simulate the one or more models of physical systems. In response to an input received via one or more input devices, one or more new window forms are defined. In response to defining the one or more new window forms, window form data representing the defined one or more new window forms are added to the initial application data structure via at least one of the one or more modeling system processing units. One or more selections for application features from one or more user-selectable application feature options displayed in one or more of the application builder wizard graphical user interfaces are receive via at least one of the one or more input devices. In response to receiving the one or more selections, application feature data corresponding to the received one or more selections are added via at least one of the one or more processing units. The application feature data represents one or more application features for the one or more new window forms. The application feature data is added to the initial application data structure to create a modified application data structure that further includes the window form data. Each added application feature comprises one or more of (i) first data representing at least one widget included in at least one of the new window forms, (ii) second data representing at least one widget collection included in at least one of the new window forms, (iii) third data representing at least one form feature included in at least one of the new window forms, (iv) fourth data representing at least one form collection feature included in at least one of the new window forms and/or (v) fifth data representing at least one command sequence initiated through the new window form. The at least one form feature or the at least one form collection feature comprises one or more fields for specifying input data and/or output data and/or presentation format of input and/or output data. The command sequence comprises data specifying a sequence of operations to be carried out when executing an application defined by the modified application data structure. The at least one widget or widget collection is linked to the command sequence such that selection of the at least one widget or widget collection, during execution of the application, is operable to initiate a command sequence. The command sequence includes execution of at least one operation for the one or more models of physical systems defined in the embedded multiphysics model data structure. The modified application data structure is generated via at least one of the one or more modeling processing units. The generated modified application data structure is stored on one or more memory devices of the multiphysics modeling system. The generated modified application data structure provides, when executed, a customized modeling of the physical systems in response to customized user inputs received via one or more new window forms and one or more application features for the one or more new window forms.
- An Alternative Embodiment AA includes the aspects of the computer-implemented method of Alternative Embodiment Z and further includes that the at least one widget or the at least one widget collection includes a link to the command sequence. The at least one operation for the command sequence corresponds to a study to be applied to the one or more models defined in the embedded multiphysics model data structure. The least one operation further corresponds to an update to an output form including an update to a plot corresponding to the model defined in the embedded model data structure. The update to the plot is in response to execution of a sequence of operations for the study.
- An Alternative Embodiment AB includes the any one of the aspects of the computer-implemented methods of Alternative Embodiment Z to AA and further includes that the at least one form feature is an output form feature. The output form feature includes a graphics widget or a graphics widget collection linked to one of a plot group, a geometry, and/or a mesh for the one or more models in the embedded multiphysics model data structure.
- An Alternative Embodiment AC includes any one of the aspects of the computer-implemented methods of Alternative Embodiments Z to AB and further includes that the one or more new window forms are defined based on the receipt of one or more new window selections from a list of one or more displayed user-selectable window form options.
- An Alternative Embodiment AD includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AC and further includes that the at least one widget comprises data specifying an input field linked to a parameter in the multiphysics model data structure embedded in the modified application data structure.
- An Alternative Embodiment AE includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AD and further includes that the widget collection comprises an input field, the first data representing the input field, the first data further representing an input label and an input units label describing an expected user input for the input field.
- An Alternative Embodiment AF includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AE and further includes that the widget collection, including the input field, the input label, and/or the input units label, is displayed in a preview in one of the one or more application builder wizard graphical user interfaces, the display occurring in response to one of the one or more selections including the at least one widget collection.
- An Alternative Embodiment AG includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AF and further includes that a user selection is received for a modeling operation that sets an input parameter for modeling the physical systems, data representing the user selection for the modeling operation being included in the generated modified application data structure such that, when executed, provides a customized application for modeling the physical systems, the customized application including the selected modeling operation, the widget collection being linked to the modeling operation.
- An Alternative Embodiment AH includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AG and further includes that the at least one form feature and/or the at least one widget are a combo box that displays a list of choices on a graphical user interface displaying one of the new window forms during execution of the generated modified application data structure, the list of choices corresponding to string data values.
- An Alternative Embodiment AI includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AH and further includes that the at least one widget feature includes a check-box widget and/or a button widget.
- An Alternative Embodiment AJ includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AI and further includes that the at least one operation for the command sequence corresponds to a study to be applied to the one or more models defined in the embedded multiphysics model data structure.
- An Alternative Embodiment AK includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AJ and further includes that the at least one operation corresponds to an update to an output form that includes an update to a plot corresponding to simulation results for the one or more models defined in the embedded multiphysics model data structure, the update to the plot being in response to execution of a series of operations for the study.
- An Alternative Embodiment AL includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AK and further includes that the at least one form feature, at least one widget, and/or the command sequence are added to the modified application data structure based on one or more received selections from one or more lists of user-selectable options displayed to a system user in the application builder wizard graphical user interface.
- An Alternative Embodiment AM includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AL and further includes that the at least one form feature is an output form or an output form collection feature, the output form or output form collection feature including a graphics widget and/or a graphics widget collection linked to one of a plot group, a geometry, and/or a mesh for the one or more models in the embedded multiphysics model data structure.
- An Alternative Embodiment AN includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AM and further includes that the graphics widget or graphics widget collection is configured to display data from an output declaration.
- An Alternative Embodiment AO includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AN and further includes that the system user is guided in creating new application features, the guiding including displaying to the system user one or more first lists of modeling operations and/or sequences of operations available in the embedded multiphysics model data structure; and in response to receiving a user selection of one or more modeling operations or sequences of operations from the first lists, the selected operations being displayed to the system user in one or more second lists, the displayed second lists showing modeling operations or sequences of operations linked to at least one of the new application features.
- An Alternative Embodiment AP includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AO and further includes that the new application features include one or more of a new widget, widget collection, form feature, and/or form collection feature.
- An Alternative Embodiment AQ includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AP and further includes that at least one of the first list and/or the second list includes a display of indicia representing that the selected modeling operations and/or sequences of operations are linked to an input widget or input widget collection, an output widget or output widget collection, a graphics widget or graphics widget collection, and/or a button widget or button widget collection.
- An Alternative Embodiment AR includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AQ and further includes that at least one of the one or more application builder wizard graphical user interfaces includes a preview displaying the new window form; and wherein in response to receiving the one or more selections, the preview is updated to display a representation of one or more of the added widgets or form features.
- An Alternative Embodiment AS includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AR and further includes that the preview is updated to display a representation of the at least one widget in the new window form.
- An Alternative Embodiment AT includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AS and further includes that the at least one widget is a graphics widget for displaying modeling results as plots, the preview being updated to display a representation of the graphics widget.
- An Alternative Embodiment AU includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AT and further includes that the one or more application feature options comprise a plurality of user-selectable options for modeling operations, the plurality of user-selectable options including one or more of defining input parameters, defining material properties, defining functions, defining physical properties, defining physical quantities, defining operators, defining result settings, defining variables, defining variable expressions, defining study settings, defining boundary conditions, defining initial conditions, and/or defining initial values for the physical systems being modeled.
- An Alternative Embodiment AV includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AT and further includes that the one or more application feature options comprise a plurality of user-selectable options for modeling operations, the plurality of user-selectable options including command sequences for one or more of building a geometry, displaying a geometry, building a mesh, displaying a mesh, computing numerical equations, displaying results, evaluating results, and/or plotting results.
- An Alternative Embodiment AW includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AV and further includes that the plurality of user-selectable options includes displaying modeling results as plots.
- An Alternative Embodiment AX includes the aspects of any one of the computer-implemented methods of Alternative Embodiments Z to AW and further includes that the at least one widget is a button widget linked to a command sequence, the preview being updated to display a representation of the button widget linked to the command sequence.
- Each of the aspects described above and obvious variations thereof are contemplated as falling within the spirit and scope of the claimed invention, which is set forth in the following claims.
- In the claims, any reference signs placed between parentheses shall not be constructed 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 (21)
1. A system adapted to generate a modified application data structure for modeling physical systems, the modified application data structure being generated from guided user inputs received through one or more application builder wizard graphical user interfaces, the system comprising:
one or more modeling system processing units, one or more user input devices, optionally a display device, and one or more memory devices, the one or more modeling processing units being adapted, during use, to
embed a pre-determined or a user-selected multiphysics model data structure in an initial application data structure, wherein the multiphysics model data structure comprises data representing one or more models of physical systems, each model of a physical system representing physical phenomena and/or physical processes, the multiphysics model data structure further comprising data representing at least one modeling operation for determining how to model or simulate the one or more models of physical systems,
define one or more new window forms,
in response to defining the one or more new window forms, add window form data representing the defined one or more new window forms to the initial application data structure,
receive one or more selections for application features from one or more user-selectable application feature options displayed in one or more of the application builder wizard graphical user interfaces, and
in response to receiving the one or more selections, add application feature data corresponding to the received one or more selections, the application feature data representing one or more application features for the one or more new window forms, the application feature data being added to the initial application data structure to create a modified application data structure that further includes the window form data, each added application feature comprising one or more of (i) first data representing at least one widget included in at least one of the new window forms, (ii) second data representing at least one form feature included in at least one of the new window forms, and/or (iii) third data representing at least one command sequence initiated through the at least one widget included in at least one new window form,
wherein the at least one form feature comprises one or more fields for specifying input data and/or output data and/or presentation format of input and/or output data, and wherein a command sequence comprises data specifying a sequence of operations to be carried out when executing an application defined by the modified application data structure, and
wherein the at least one widget is linked to the command sequence such that selection of the at least one widget, during execution of the application, is operable to initiate the command sequence, the command sequence including execution of at least one operation for the one or more models of physical systems defined in the embedded multiphysics model data structure,
whereby a modified application data structure is generated and stored in the one or more memory devices, the generated modified application data structure providing, when executed, a customized modeling of the physical systems in response to customized user inputs received via the one or more new window forms and the one or more application features for the one or more new window forms.
2. The system of claim 1 , wherein the at least one widget is a plurality of widgets defining a widget collection.
3. The system of claim 1 , wherein the at least one widget comprises data specifying an input field linked to a parameter in the multiphysics model data structure embedded in the modified application data structure.
4. The system of claim 2 , wherein the widget collection comprises an input field, the first data representing the input field, the first data further representing an input label and an input units label describing an expected user input for the input field.
5. The system of claim 2 , wherein the widget collection, including the input field, the input label, and the input units label, is displayed in a preview in one of the one or more application builder wizard graphical user interfaces, the display occurring in response to one of the one or more selections including the at least one widget collection.
6. The system of claims 2 , wherein a user selection is received for a modeling operation that sets an input parameter for modeling the physical systems, data representing the user selection for the modeling operation being included in the generated modified application data structure such that, when executed, provides a customized application for modeling the physical systems, the customized application including the selected modeling operation, the widget collection being linked to the modeling operation.
7. The system of claim 1 , wherein the at least one form is a plurality of forms that define a form collection.
8. The system of claim 1 , wherein the at least one form feature and the at least one widget are a combo box that displays a list of choices on a graphical user interface displaying one of the new window forms during execution of the generated modified application data structure, the list of choices corresponding to string data values.
9. The system of claim 1 , wherein the at least one widget feature includes one of a check-box widget or a button widget.
10. The system of claim 1 , wherein the at least one operation for the command sequence corresponds to a study to be applied to the one or more models defined in the embedded multiphysics model data structure.
11. The system of claim 10 , wherein the at least one operation corresponds to an update to an output form that includes an update to a plot corresponding to simulation results for the one or more models defined in the embedded multiphysics model data structure, the update to the plot being in response to execution of a series of operations for the study.
12. The system of claim 1 , wherein the at least one form feature, at least one widget, and/or the command sequence are added to the modified application data structure based on one or more received selections from one or more lists of user-selectable options displayed to a system user in the application builder wizard graphical user interface.
13. The system of claim 1 , wherein the at least one form feature is an output form or an output form collection feature, the output form or output form collection feature including a graphics widget or a graphics widget collection linked to one of a plot group, a geometry, or a mesh for the one or more models in the embedded multiphysics model data structure.
14. The system of claim 13 , wherein the graphics widget or graphics widget collection is configured to display data from an output declaration.
15. The system of claim 1 , wherein the system user is guided in creating new application features, the guiding including displaying to the system user one or more first lists of modeling operations and/or sequences of operations available in the embedded multiphysics model data structure; and in response to receiving a user selection of one or more modeling operations or sequences of operations from the first lists, the selected operations being displayed to the system user in one or more second lists, the displayed second lists showing modeling operations or sequences of operations linked to at least one of the new application features.
16. The system of claim 15 , wherein the new application features include one or more of a new widget, widget collection, form feature, or form collection feature.
17. The system of claim 15 , wherein at least one of the first list or the second list includes a display of indicia representing that the selected modeling operations or sequences of operations are linked to an input widget or input widget collection, an output widget or output widget collection, a graphics widget or graphics widget collection or a button widget or button widget collection.
18. The system of claim 1 , wherein at least one of the one or more application builder wizard graphical user interfaces includes a preview displaying the new window form; and wherein in response to receiving the one or more selections, the preview is updated to display a representation of one or more of the added widgets or form features.
19. The system of claim 18 , wherein the preview is updated to display a representation of the at least one widget in the new window form.
20. The system of claim 19 , wherein the at least one widget is a graphics widget for displaying modeling results as plots, the preview being updated to display a representation of the graphics widget.
21-27. (canceled)
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US15/158,293 US20160266877A1 (en) | 2014-09-12 | 2016-05-18 | Systems and methods for creating user interfaces for guiding the creation of modeling applications for forming and solving problems in a multiphysics modeling system |
Applications Claiming Priority (3)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US201462050014P | 2014-09-12 | 2014-09-12 | |
US14/852,352 US9372673B2 (en) | 2014-09-12 | 2015-09-11 | Systems and methods for creating user interfaces for guiding the creation of modeling applications for forming and solving problems in a multiphysics modeling system |
US15/158,293 US20160266877A1 (en) | 2014-09-12 | 2016-05-18 | Systems and methods for creating user interfaces for guiding the creation of modeling applications for forming and solving problems in a multiphysics modeling system |
Related Parent Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US14/852,352 Continuation US9372673B2 (en) | 2014-09-12 | 2015-09-11 | Systems and methods for creating user interfaces for guiding the creation of modeling applications for forming and solving problems in a multiphysics modeling system |
Publications (1)
Publication Number | Publication Date |
---|---|
US20160266877A1 true US20160266877A1 (en) | 2016-09-15 |
Family
ID=54238559
Family Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US14/852,352 Active US9372673B2 (en) | 2014-09-12 | 2015-09-11 | Systems and methods for creating user interfaces for guiding the creation of modeling applications for forming and solving problems in a multiphysics modeling system |
US15/158,293 Abandoned US20160266877A1 (en) | 2014-09-12 | 2016-05-18 | Systems and methods for creating user interfaces for guiding the creation of modeling applications for forming and solving problems in a multiphysics modeling system |
Family Applications Before (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US14/852,352 Active US9372673B2 (en) | 2014-09-12 | 2015-09-11 | Systems and methods for creating user interfaces for guiding the creation of modeling applications for forming and solving problems in a multiphysics modeling system |
Country Status (2)
Country | Link |
---|---|
US (2) | US9372673B2 (en) |
WO (1) | WO2016040878A1 (en) |
Families Citing this family (16)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US11934752B1 (en) | 2013-02-04 | 2024-03-19 | Comsol Ab | System and method for adding and defining perfectly matched layers for a model of a physical system |
US10019238B2 (en) | 2015-06-23 | 2018-07-10 | Open Text Sa Ulc | Compositional entity modeling systems and methods |
US10489122B1 (en) * | 2015-09-02 | 2019-11-26 | Devin Abbott | Inline text editor elements as an abstraction layer for graphical code editing |
US10706187B1 (en) | 2015-10-01 | 2020-07-07 | Comsol Ab | Systems and methods for reducing application startup times for physics modeling applications |
US20170322716A1 (en) | 2016-05-04 | 2017-11-09 | Open Text Sa Ulc | Reusable entity modeling systems and methods |
US11030365B1 (en) | 2016-05-11 | 2021-06-08 | Comsol Ab | Systems and methods for determining finite elements in physics simulation systems for modeling physical systems using common geometry shape function spaces |
CN108279885B (en) * | 2017-01-03 | 2021-04-09 | 中国航发商用航空发动机有限责任公司 | Method and device for integrating software of multiple model codes |
US11093665B2 (en) * | 2017-10-25 | 2021-08-17 | Lockheed Martin Corporation | System and method for simulation visualization |
US20190126558A1 (en) * | 2017-11-02 | 2019-05-02 | Eos Gmbh Electro Optical Systems | Method and assembly for generating control data for the manufacture of a three-dimensional object by means of an additive manufacturing method |
AU2018410087B2 (en) * | 2018-02-20 | 2021-04-29 | Tata Consultancy Services Limited | A server controlled framework for controlling widgets of a tabular structure |
US10936864B2 (en) * | 2018-06-11 | 2021-03-02 | Adobe Inc. | Grid layout determination from a document image |
CN109144511B (en) * | 2018-08-16 | 2020-10-13 | 北京应用物理与计算数学研究所 | Method and system for automatically generating numerical simulation graphical user interface |
US11893318B1 (en) | 2019-09-19 | 2024-02-06 | Comsol Ab | Systems and methods for topology and shape optimization for modeling of a physical object |
LU101660B1 (en) * | 2020-03-03 | 2021-09-03 | Luxembourg Inst Science & Tech List | Multi-user complex problems resolution system |
US11119737B1 (en) * | 2020-08-10 | 2021-09-14 | Adp, Llc | Dynamic column guides and data representation on an application development workspace |
CN112035046B (en) * | 2020-09-10 | 2024-03-08 | 脸萌有限公司 | Method and device for displaying list information, electronic equipment and storage medium |
Family Cites Families (11)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US7596474B2 (en) | 2000-08-02 | 2009-09-29 | Comsol Ab | Method for assembling the finite element discretization of arbitrary weak equations involving local or non-local multiphysics couplings |
US9208270B2 (en) | 2000-08-02 | 2015-12-08 | Comsol Ab | System and method for establishing bidirectional links between multiphysics modeling and design systems |
US7519518B2 (en) | 2000-08-02 | 2009-04-14 | Comsol Ab | Method for assembling the finite element discretization of arbitrary weak equations, involving local or non-local multiphysics couplings |
US7623991B1 (en) | 2000-08-02 | 2009-11-24 | Comsol Ab | Method and apparatus for the specification and automatic derivation of partial differential equations associated with coupled physical quantities in a multiphysics problem |
US7624375B2 (en) * | 2003-06-12 | 2009-11-24 | National Instruments Corporation | Automatically configuring a graphical user interface element to bind to a graphical program |
US8219373B2 (en) | 2005-08-19 | 2012-07-10 | Comsol Ab | System and method for graphically creating models for simulating systems of reacting species |
US8019579B1 (en) | 2007-10-16 | 2011-09-13 | The Mathworks, Inc. | Graphical user interface for viewing or editing an executable block diagram model |
EP2286356A4 (en) * | 2008-06-03 | 2013-03-06 | Whirlpool Co | Appliance development toolkit |
US8626475B1 (en) | 2009-12-29 | 2014-01-07 | Comsol Ab | System and method for accessing a multiphysics modeling system via a design system user interface |
US9098106B2 (en) | 2012-08-10 | 2015-08-04 | Comsol Ab | Systems and methods for creating application interfaces for forming and solving problems in a modeling system |
EP3474166A1 (en) | 2012-12-20 | 2019-04-24 | Comsol AB | System and method for creating reusable geometry sequences for multiphysics modeling |
-
2015
- 2015-09-11 WO PCT/US2015/049808 patent/WO2016040878A1/en active Application Filing
- 2015-09-11 US US14/852,352 patent/US9372673B2/en active Active
-
2016
- 2016-05-18 US US15/158,293 patent/US20160266877A1/en not_active Abandoned
Also Published As
Publication number | Publication date |
---|---|
WO2016040878A1 (en) | 2016-03-17 |
US20160077810A1 (en) | 2016-03-17 |
US9372673B2 (en) | 2016-06-21 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US9372673B2 (en) | Systems and methods for creating user interfaces for guiding the creation of modeling applications for forming and solving problems in a multiphysics modeling system | |
JP6298055B2 (en) | System and method for creating application interfaces for forming and answering problems in a modeling system | |
US20220343041A1 (en) | System and method for creating application interfaces for multiphysics modeling | |
EP3436933B1 (en) | Systems and methods for automatic determination of layout constraints | |
US8949089B1 (en) | System and apparatus for accessing a multiphysics modeling system via a design system user interface | |
US9323503B1 (en) | System and method for accessing settings in a multiphysics modeling system using a model tree | |
US8806429B2 (en) | Dynamic generation of formatted user interfaces in software environments | |
Multiphysics | Introduction to comsol multiphysics® | |
JP6298075B2 (en) | System and method for creating reusable shape sequences for complex physical modeling | |
KR20190038793A (en) | User interface with movable minitaps | |
Victoria et al. | liteITD a MATLAB Graphical User Interface (GUI) program for topology design of continuum structures | |
Kasyanov | Methods and tools for structural information visualization | |
US11366567B2 (en) | Preferential automation view curation | |
Collignon et al. | Model-driven engineering of multi-target plastic user interfaces | |
Du et al. | Graph-It: Design and implementation of a Graph Theory toolbox and visualization application | |
Noack et al. | An integrated simulation environment for cfd and other computational disciplines | |
Armbruster | A graphical editor for structural screen models | |
Miteshkumar | Semester Long Internship Report | |
Silva | 2D Graphics with GEF and Zest | |
Xiao | Extending two drawing frameworks to create LaTeX picture environments |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
STCB | Information on status: application discontinuation |
Free format text: ABANDONED -- INCOMPLETE APPLICATION (PRE-EXAMINATION) |