|Publication number||US6966053 B2|
|Application number||US 09/928,042|
|Publication date||15 Nov 2005|
|Filing date||10 Aug 2001|
|Priority date||10 Aug 2001|
|Also published as||US20030033038|
|Publication number||09928042, 928042, US 6966053 B2, US 6966053B2, US-B2-6966053, US6966053 B2, US6966053B2|
|Inventors||John Kenneth Floyd Paris, William Wallace Follett, IV|
|Original Assignee||The Boeing Company|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (35), Non-Patent Citations (6), Referenced by (22), Classifications (8), Legal Events (4)|
|External Links: USPTO, USPTO Assignment, Espacenet|
The present invention relates generally to design and analysis systems, and more particularly to a method and architecture for determining design and analysis parameters for use during various stages of a design process.
The design of many modern systems (e.g., complex aircraft design) continue to grow in size and complexity, such that automation of the processes involved are crucial. As a result, attempts have been made to improve the efficiency of the design process through automation. In particular, the area of multidisciplinary optimization (MDO) attempts to improve the design process by exploiting interactions between different disciplines and components. Design flexibility and reusability of interfaces is essential to improving MDO.
Software products for automating design and/or model assembly by wrapping an additional interface layer (e.g., coded logic) around an analysis package (e.g., Analysis ServerŪ by Phoenix Integration and iSight by Engineers Software, Inc.) are known. However, because of the increasing capabilities of computers and the software that runs on them, the design problems that must be addressed by MDO continue to increase in size and complexity. Specifically, the number of design variables, constraints and disciplines for the typical MDO problem is increasing (e.g., problems may include hundreds of design variables). For example, the code required for a scramjet combustion analysis and design may require over 100 inputs to specify geometry, boundary conditions and run option parameters. A user at the vehicle conceptual design stage may only specify a few input variables, with a software code wrapper component created to define all remaining variables as constants or complex functions of the specified inputs. However, if the user decides to use a different set of inputs, new logic and/or functions must be coded into the wrapper for every set of design variable combinations that changes as a result of the new set of inputs. The flexibility of the wrapped code is limited.
Known software products that automate model assembly by wrapping an additional interface layer around analysis packages traditionally provide analysis code automation using scripting languages (e.g., UNIX, PERL, Tcl, etc.). Users must explicitly define the hierarchical relationship between variables (e.g., by writing an intermediate script that calculates dependent input parameters in the proper order).
Still other systems have been developed to provide user-friendly software tools to enable users to automate analysis codes by pointing and clicking on a Graphical User Interface (GUI) or by using a semi-graphical interface, instead of programming in a lower level scripting language. Essentially, these systems attempt to reduce the expertise level required to wrap codes. However, such systems fail to provide design flexibility throughout the entire design process (i.e., from the conceptual design stage through the preliminary and detailed design stages).
Different needs must also be met at each design level. For example, at the conceptual design stage, a typical user of analysis software is a systems engineer with limited knowledge of software code. Thus, few, if any, design variables will be changed. Only default values are required for the majority of input values for the analysis program. These default values are typically chosen to provide good predicted performance, good solution quality and robust solution convergence. However, the detailed design stage may involve a more knowledgeable user that desires to override default values to refine a particular design. Default values or functions may be readily defined for dependent input parameters that are a function of selected input parameters. However, as the analysis problem becomes more complex, some dependent input parameters are functions of one or more other dependent input parameters or variables. Thus, the relationship between parameters and/or variables rapidly becomes complex and extremely difficult to define by a user.
Thus, known systems for wrapping design/analysis software are time-consuming, prone to errors, restrict the flexibility of the wrapped software module because of hard-coded logic and make module maintenance extremely difficult. For design and analysis problems that contain a large number of input parameters, the determination of the order of parameter calculation requires complex evaluation of all variables. Further, customization is required to reuse the wrapped software modules in connection with different design/analysis problems and applications (i.e., extremely limited plug-and-play reusable module support).
The present invention provides a method and interface for use in all stages of a design and analysis process to determine parameter values. Generally, the present invention provides automation or “wrapping” of code (the “wrapper”) around an analysis program to create flexible plug-and-play interfaces for wrapped software code, as well as maximizing the potential for reusing the wrapped software. The invention further simplifies the wrapping of complex codes having many interdependent input parameters using a recursive branching algorithm to automatically determine the relationships between input parameters. Input parameters may be specified explicitly or computed by the wrapper using default functions depending upon the requirements of a particular application or of the particular design stage. Thus, the present invention provides for ease in changing a design problem definition.
The present invention provides smart defaults for more flexible and robust analysis code operation. These smart defaults enable experienced engineers to wrap their knowledge around the analysis code. In addition, defining different data parameter types, which are used by the recursive branching algorithm, provides simplified specification of complex variable relationships, thereby enhancing the maintainability of wrapped software. Thus, initial wrapping of large problems with complex relationships between variables is simplified, while engineering flexibility after the code has been wrapped is maximized. Further, the number of parameters that a user must specify to run the code is reduced, which is particularly beneficial for less experienced users.
The present invention provides for overriding smart defaults if desired (e.g., by experienced users). For example, an engineer may choose to optimize a design project based upon a selected set of independent design parameters, relying on the wrapper to calculate the remaining input parameters using smart defaults. However, the engineer may then attempt to improve the design by performing a secondary optimization in which a different set of independent parameters is varied. A wrapped software module of the present invention is not only adapted for plug-and-play adaptability to any changes, but is flexible in all modes of operation because relationship hierarchies for parameters are determined “on the fly” based upon user input changes. Essentially, calculated dependent parameters (i.e., smart defaults) are defined based upon local parameter relationships. The order of parameter calculation is determined automatically “on the fly”. More specifically, global parameter relationship hierarchy is automatically determined based upon the specification of local parameter relationships.
The smart defaults calculate unspecified parameters based in part on parameter types (e.g., calculates optional parameters not specified). Other parameter types are preferably provided that restrict any overriding or specifying of particular values by, for example, a user, such as those parameter types calculated by the smart defaults using internal functions and values.
Thus, the present invention provides a method for wrapping analysis code to thereby create a flexible interface that enhances plug-and-play modularity, simplifies the specification of complex variable relationships and enhances maintainability of wrapped software. The wrapped analysis code (i.e., the wrapper) automatically determines the relationship between all potential input parameters preferably using a recursive branching algorithm, with specific parameter types defined. The parameter values are calculated using the determined parameter relationships. Any unspecified input parameters (e.g., optional parameters) are determined using smart defaults of the present invention.
Further areas of applicability of the present invention will become apparent from the detailed description provided hereinafter. It should be understood that the detailed description and specific examples, while indicating the preferred embodiment of the invention, are intended for purposes of illustration only and are not intended to limit the scope of the invention.
The present invention will become more fully understood from the detailed description and the accompanying drawings, wherein:
The following description of the preferred embodiments is merely exemplary in nature and is in no way intended to limit the invention, its application, or uses. Thus, although the application of the present invention as disclosed herein is described in connection with specific examples, including using specific structures or algorithms, it is not so limited and may be provided in connection with different applications.
The present invention provides a more flexible code wrapping method and architecture which forms an interface for use during the design process 20 in combination with, for example, an analysis package. As shown in
The present invention provides a software wrapper 40 and/or architecture (e.g., an interface), and method of providing the same that incorporates smart defaults 42 based upon engineering expertise. Smart defaults provide the opportunity for experienced engineers to wrap their knowledge around analysis code. Referring specifically to
As shown in
For example, and referring to
The use of the recursive branching algorithm 58 as described herein provides for determining parameter relationship and calculating the values of any unspecified non-required parameters. More preferably, the branching algorithm 58 automatically determines a global parameter structure, such as if one parameter is dependent upon other parameters, which may be independent or dependent parameters, based upon local parameter relationships. The branching algorithm 58 then executes the needed functions (i.e., smart defaults 42) in an automatically determined order to calculate all of the parameter values.
As shown in
The pseudo-code for a particularly preferred algorithm 58 for use with a wrapper 40 is provided as follows:
Preferably, if the subroutine 66 calls a smart default 42 function to determine the value of a parameter, and the function is dependent on other parameters, then the subroutine 66 is called to determine the value of each dependent parameter, which themselves may be dependent on other parameters as defined by the associated smart default 42 function or functions (i.e., indirect recursion). Thus, as shown in the example of
It should be noted that returning a value refers to the wrapper 40 providing a calculated parameter value or specified parameter value using known software programming methods. For example, in object-oriented programming, a parameter object may have a default method named “value,” that when invoked, computes the value of the parameter and hands it back (i.e., returns) to the statement that invoked the “value” method. When referring to calling a function or routine, this means using known software programming methods to execute the function or routine. For example, this may be a simple “call” made in FORTRAN or Perl, or a method could be invoked in an object-oriented language.
A wrapper 40 of the present invention preferably includes defined input parameter types. The parameter types are preferably defined during the initial wrapping process by a user, and may include, for example, the following:
It should be noted that a parameter is assigned the status of “initialized” once the parameter is calculated internally by a smart default 42 function or explicitly specified as an input to the wrapped module. As described herein, both required and optional parameters may be specified. If the status of optional or locked parameters is not set to initialized, the parameters are preferably re-calculated the next time the value is requested by the subroutine 66.
It should also be noted that required parameters and any desired parameter overrides (e.g., overrides of optional parameters) must be specified before a wrapper 40 of the present invention may determine the remaining locked and unspecified optional input parameters. A parameter value may be specified from one of a plurality of sources, including, for example: (1) defined directly by a user; (2) linked from the output of an upstream analysis module; or (3) provided by a software framework launching the wrapped analysis module.
Smart default 42 preferably refers to the specific programming provided as part of the wrapper 40 (e.g., coded engineering expertise) and may be created using, for example, a scripting language (e.g., PERL, Python, etc.). Depending upon the needs of the analysis program and the parameters to be calculated, the smart defaults 42 may include, for example, any type of executable routines having simple constants and/or advanced mathematical functions (e.g., predetermined functions). The scripting language may support a set of intrinsic mathematical functions, conditional statements and other programming functionality (e.g., “for” loops) for use in defining the smart defaults 42. Alternately, an external program may be provided for use by a smart default 42 in calculating a parameter value.
Input parameters are preferably checked for consistency with the defined parameter types and associated wrapper 40 rules (i.e., locked and required parameter checks) upon execution of a software module incorporating the wrapper 40. More preferably, automatic checks are performed to identify whether additional parameters need to be specified and/or whether locked parameters have been improperly specified. For example, if a required parameter has no specified value, upon execution of a software module having the wrapper 40, an indication is provided as to this condition (e.g., user interactively prompted to enter parameter value or return an error message and halt the program). As another example, if a locked parameter has been specified, an indication is provided as to this condition, such as an appropriate warning or error message. Alternately, consistency checks may be provided by the framework employing a wrapper 40, such as with a user interface.
The architecture (e.g., interface) and method of the present invention for creating a wrapper 40 may be provided with additional functionality, including, but not limited to, new and/or additional parameter types, a GUI, different input/output interface techniques and/or modification to the branching algorithm 58. Instead of incorporating the architecture and method of the present invention into a wrapper 40, all or part thereof may be provided as part of an existing framework (e.g., an MDO framework, automated analysis/design framework, etc.).
In operation, a wrapper 40 of the present invention determines a set of values for an analysis component 50 input interface 44 using specified parameters and unspecified calculated parameters such as those calculated using the smart defaults 42. The values of the unspecified parameters may be determined based upon other specified and/or unspecified parameters. For example, the present invention may be implemented to determine a set of input values for making pink lemonade. Specifically, to produce pink lemonade, the following functions (i.e., defining local relationships) may be specified to determine and/or define the quantity of each ingredient and container size needed (i.e., to determine the input values based upon the relationships of the inputs):
The global structure 70 needed to define the relationship among the parameters for making pink lemonade based upon the above local equations is shown in
For example, if the quantity of water is to be determined, the tree structure 72 as shown in
Although the present invention is described as a wrapper 40 in connection with analysis programs, it should be appreciated that different or additional components may be provided as part of the wrapper 40 depending upon the particular system requirements, as in the above example, the wrapper computes inputs for a lemonade making apparatus or recipe-generating software. Further, external functionality for defining parameter types and monitoring parameter specification may be provided. Also, although parameter relationships and calculation are determined based in part on a dynamically generated structure, other structures may be provided. A wrapper 40 constructed according to the principles of the present invention may be used in combination with software modules or may be embedded within hardware components.
The description of the invention is merely exemplary in nature and, thus, variations that do not depart from the gist of the invention are intended to be within the scope of the invention. Such variations are not to be regarded as a departure from the spirit and scope of the invention.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US4227245 *||1 Jun 1972||7 Oct 1980||Westinghouse Electric Corp.||Digital computer monitored system or process which is configured with the aid of an improved automatic programming system|
|US5301270 *||18 Dec 1989||5 Apr 1994||Anderson Consulting||Computer-assisted software engineering system for cooperative processing environments|
|US5404534 *||1 Jun 1994||4 Apr 1995||Sun Microsystems, Inc.||Method and apparatus for extensible object-oriented inter-application link management|
|US5522022 *||24 Nov 1993||28 May 1996||Xerox Corporation||Analyzing an image showing a node-link structure|
|US5630069 *||15 Jan 1993||13 May 1997||Action Technologies, Inc.||Method and apparatus for creating workflow maps of business processes|
|US5724483 *||7 Jun 1995||3 Mar 1998||Sgs-Thomson Microelectronics S.R.L.||Fuzzy logic electronic controller and associated method for setting up memories thereof|
|US5732191 *||14 Sep 1994||24 Mar 1998||Siemens Aktiengesellschaft||Method and apparatus for rule evaluation in a fuzzy inference processor|
|US5748966 *||30 Dec 1994||5 May 1998||The Trustees Of The University Of Pennsylvania||Type error checker for type-free or polymorphic computer language|
|US5761509 *||13 Feb 1997||2 Jun 1998||International Business Machines Corporation||System and method for enabling before/after method processing in an object oriented system|
|US5787440 *||4 Mar 1996||28 Jul 1998||Crossties Software Corp.||Object oriented architecture with bidirectional linking of relationships between objects|
|US5790755 *||28 Jul 1994||4 Aug 1998||Sgs-Thomson Microelectronics S.R.L.||Fuzzy logic electronic controller architecture having two section membership function memory|
|US5809490 *||3 May 1996||15 Sep 1998||Aspen Technology Inc.||Apparatus and method for selecting a working data set for model development|
|US5963739 *||25 Apr 1997||5 Oct 1999||Peter V. Homeier||Method for verifying the total correctness of a program with mutually recursive procedures|
|US5983016 *||12 Nov 1996||9 Nov 1999||International Business Machines Corporation||Execution engine in an object modeling tool|
|US6167523 *||5 May 1997||26 Dec 2000||Intel Corporation||Method and apparatus for forms data validation and processing control|
|US6192381 *||2 Oct 1998||20 Feb 2001||Megg Associates, Inc.||Single-document active user interface, method and system for implementing same|
|US6230315 *||19 Mar 1998||8 May 2001||International Business Machines Corporation||Data processing method and apparatus|
|US6260030 *||1 Dec 1997||10 Jul 2001||Talib Janabi||Multi grade fuzzy logic controller|
|US6282526 *||20 Jan 1999||28 Aug 2001||The United States Of America As Represented By The Secretary Of The Navy||Fuzzy logic based system and method for information processing with uncertain input data|
|US6341372 *||16 Jun 1997||22 Jan 2002||William E. Datig||Universal machine translator of arbitrary languages|
|US6345278 *||3 Jun 1999||5 Feb 2002||Collegenet, Inc.||Universal forms engine|
|US6389414 *||21 Sep 1998||14 May 2002||Microsoft Corporation||Internal database validation|
|US6424957 *||26 Sep 1997||23 Jul 2002||Consorzio Per La Ricerca Sulla Microelettronica Nel Mezzogiorno||Method and apparatus for parallel processing of fuzzy rules|
|US6460042 *||9 Nov 2001||1 Oct 2002||Collegenet, Inc.||Universal forms engine|
|US6463582 *||21 Oct 1998||8 Oct 2002||Fujitsu Limited||Dynamic optimizing object code translator for architecture emulation and dynamic optimizing object code translation method|
|US6467052 *||3 Jun 1999||15 Oct 2002||Microsoft Corporation||Method and apparatus for analyzing performance of data processing system|
|US6484312 *||7 Jun 1999||19 Nov 2002||Microsoft Corporation||Inferring operand types within an intermediate language|
|US6493868 *||2 Nov 1999||10 Dec 2002||Texas Instruments Incorporated||Integrated development tool|
|US6535864 *||5 Aug 1999||18 Mar 2003||Unisys Corporation||Method for mapping alterations in system state to knowledge base objects in a persistent repository-resident knowledge base|
|US6546551 *||28 Sep 1999||8 Apr 2003||International Business Machines Corporation||Method for accurately extracting library-based object-oriented applications|
|US6560774 *||1 Sep 1999||6 May 2003||Microsoft Corporation||Verifier to check intermediate language|
|US6826748 *||24 Jun 1999||30 Nov 2004||Ati International Srl||Profiling program execution into registers of a computer|
|US6862553 *||26 Nov 2002||1 Mar 2005||Rockwell Automation Technologies, Inc.||Diagnostics method and apparatus for use with enterprise controls|
|US6883101 *||8 Feb 2000||19 Apr 2005||Harris Corporation||System and method for assessing the security posture of a network using goal oriented fuzzy logic decision rules|
|US6895573 *||26 Oct 2001||17 May 2005||Resultmaker A/S||Method for generating a workflow on a computer, and a computer system adapted for performing the method|
|1||*||SNAP Foundation Template, "Using the SNAP Development Environment", Template Software, 1997, Whole Manual.|
|2||*||SNAP Foundation Template, "Using the SNAP Language", Template Software, 1997, Chapter 6.|
|3||*||SNAP Foundation Template, "Using the SNAP Permanent Storage Component", Template Software, 1997, Whole Manual.|
|4||*||SNAP Foundation Template, Using the Communication Component, Template Software, 1997, Whole Manual.|
|5||*||Visual C++ 5 Unleashed, Vikkor Toth, 1998, pp. 375-378.|
|6||*||Workflow Process Template, "Using the WFT Development Environment", Template Software, 1997, Whole Manual.|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US7296197 *||4 Feb 2005||13 Nov 2007||Microsoft Corporation||Metadata-facilitated software testing|
|US7475051 *||22 Sep 2005||6 Jan 2009||International Business Machines Corporation||System and method for the cascading definition and enforcement of EDI rules|
|US7996758||2 Nov 2006||9 Aug 2011||Sourcecode Technologies Holding, Inc.||Methods and apparatus for storing data associated with an electronic form|
|US8010940||2 Nov 2006||30 Aug 2011||Sourcecode Technologies Holdings, Inc.||Methods and apparatus for designing a workflow process using inheritance|
|US8140494||21 Jan 2008||20 Mar 2012||International Business Machines Corporation||Providing collection transparency information to an end user to achieve a guaranteed quality document search and production in electronic data discovery|
|US8180721||4 Dec 2008||15 May 2012||International Business Machines Corporation||Cascading definition and support of EDI rules|
|US8224853||2 Nov 2006||17 Jul 2012||Sourcecode Technologies Holdings, Inc.||Methods and apparatus for updating a plurality of data fields in an electronic form|
|US8239226||2 Nov 2006||7 Aug 2012||Sourcecode Technologies Holdings, Inc.||Methods and apparatus for combining properties and methods from a plurality of different data sources|
|US8250041||22 Dec 2009||21 Aug 2012||International Business Machines Corporation||Method and apparatus for propagation of file plans from enterprise retention management applications to records management systems|
|US8275720||12 Jun 2008||25 Sep 2012||International Business Machines Corporation||External scoping sources to determine affected people, systems, and classes of information in legal matters|
|US8327384||30 Jun 2008||4 Dec 2012||International Business Machines Corporation||Event driven disposition|
|US8402359||30 Jun 2010||19 Mar 2013||International Business Machines Corporation||Method and apparatus for managing recent activity navigation in web applications|
|US8484069 *||2 Sep 2009||9 Jul 2013||International Business Machines Corporation||Forecasting discovery costs based on complex and incomplete facts|
|US8489439||2 Sep 2009||16 Jul 2013||International Business Machines Corporation||Forecasting discovery costs based on complex and incomplete facts|
|US8515924||30 Jun 2008||20 Aug 2013||International Business Machines Corporation||Method and apparatus for handling edge-cases of event-driven disposition|
|US8566903||29 Jun 2010||22 Oct 2013||International Business Machines Corporation||Enterprise evidence repository providing access control to collected artifacts|
|US8572043||28 Feb 2008||29 Oct 2013||International Business Machines Corporation||Method and system for storage of unstructured data for electronic discovery in external data stores|
|US8655856||28 Sep 2010||18 Feb 2014||International Business Machines Corporation||Method and apparatus for policy distribution|
|US8832148||29 Jun 2010||9 Sep 2014||International Business Machines Corporation||Enterprise evidence repository|
|US20050066248 *||18 Sep 2003||24 Mar 2005||Reid Hayhow||Methods and systems for determining memory requirements for device testing|
|US20060179386 *||4 Feb 2005||10 Aug 2006||Microsoft Corporation||Metadata-Facilitated software testing|
|US20090327049 *||31 Dec 2009||Kisin Roman||Forecasting discovery costs based on complex and incomplete facts|
|U.S. Classification||717/143, 706/8, 707/999.004|
|International Classification||G06F9/44, G06F9/45|
|Cooperative Classification||Y10S707/99934, G06F8/36|
|10 Aug 2001||AS||Assignment|
Owner name: THE BOEING COMPANY, WASHINGTON
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:JOHN KENNETH FLOYD PARIS;FOLLETT, WILLIAM WALLACE IV;REEL/FRAME:012080/0027
Effective date: 20010808
|15 May 2009||FPAY||Fee payment|
Year of fee payment: 4
|14 Mar 2013||FPAY||Fee payment|
Year of fee payment: 8
|21 Jun 2013||AS||Assignment|
Free format text: SECURITY AGREEMENT;ASSIGNOR:PRATT & WHITNEY ROCKETDYNE, INC.;REEL/FRAME:030656/0615
Effective date: 20130614
Owner name: U.S. BANK NATIONAL ASSOCIATION, CALIFORNIA