Case 1:21-cv-00227-UNA Document 1-4 Filed 02/18/21 Page 1 of 17 PageID #: 94
`
`
`
`
`
`
`
`Exhibit D
`
`U.S. Patent No. 6,684,220
`
`Method and System for Automatic Information Exchange
`
`

`

`Case 1:21-cv-00227-UNA Document 1-4 Filed 02/18/21 Page 2 of 17 PageID #: 95
`I 1111111111111111 11111 lllll 111111111111111 111111111111111 1111111111 11111111
`US006684220B 1
`
`(12) United States Patent
`Pfeiff er et al.
`
`(10) Patent No.:
`(45) Date of Patent:
`
`US 6,684,220 Bl
`Jan.27,2004
`
`(54) METHOD AND SYSTEM FOR AUTOMATIC
`INFORMATION EXCHANGE
`
`(75)
`
`Inventors: William P. Pfeiffer, Fort Worth, TX
`(US); Randall M. Schuessler, Fort
`Worth, TX (US); Michael R. Yokell,
`Fort Worth, TX (US)
`
`(73) Assignee: Lockheed Martin Corporation,
`Bethesda, MD (US)
`
`( *) Notice:
`
`Subject to any disclaimer, the term of this
`patent is extended or adjusted under 35
`U.S.C. 154(b) by 492 days.
`
`(21) Appl. No.: 09/666,029
`
`(22) Filed:
`
`Sep. 20, 2000
`
`Int. Cl.7 ................................................ G06F 17/30
`(51)
`(52) U.S. Cl. ....................................... 707/103 R; 707/2
`(58) Field of Search ............................. 707/103 R, 102,
`707/3, 1; 705/51, 52, 54, 57, 80; 703/22;
`713/187, 201; 717/122, 145, 176; 715/503;
`345/734, 744, 784, 821
`
`(56)
`
`References Cited
`
`U.S. PATENT DOCUMENTS
`5,801,701 A * 9/1998 Koppolu et al. ............ 345/821
`6,032,147 A
`2/2000 Williams et al. ............ 707/101
`6,038,393 A
`3/2000 Iyengar et al. .............. 395/701
`6,038,565 A
`3/2000 Nock ......................... 707/701
`6,049,807 A
`4/2000 Carroll et al.
`.............. 707/201
`6,049,822 A
`4/2000 Mittal
`........................ 709/217
`6,101,500 A * 8/2000 Lau ........................ 707/103 R
`6,282,547 Bl * 8/2001 Hirsch ........................ 707/102
`6,466,932 Bl * 10/2002 Dennis et al.
`................. 707/3
`
`FOREIGN PATENT DOCUMENTS
`
`OTHER PUBLICATIONS
`
`Bayol, Catherine, "Une Approche Structurelle et Compor(cid:173)
`tementale de la Modelisation Pour la Velisation Pour la
`Verification de Composants VLSI'', These de Docteur de
`L'Universite Joseph Fourier-Grenoble I, 129 pages, Dec.
`12, 1995.
`Donnel, Brian L., "Object/Rule Integration in CLIPS",
`Expert Systems, vol. 11, No. 1, XP001073801, Feb. 1994,
`pp. 29-45.
`Aho, Alfred V., et al, "Introduction to Compiling'', 1986,
`Addison-Wesley Series in Computer Science, Reading,
`ETATS-UNIS D'AMERIQUE, XP002200775, pgs. 1-15,
`19, 60-62, 389-396, 411-431, 1986.
`International Search Report dated Jun. 17, 2002 for PCT/
`US0l/28888 filed Sep. 17, 2001, Jun. 17, 2002.
`
`* cited by examiner
`
`Primary Examiner-Diane D. Mizrahi
`(74) Attorney, Agent, or Firm-Baker Botts, L.L.P.
`
`(57)
`
`ABSTRACT
`
`A method and system for automatic information exchange
`includes a processor and a memory coupled to the processor
`and operable to store a model. The model includes a plurality
`of objects where each of the plurality of objects includes an
`input variable and an output variable. The system also
`includes a loading engine residing in the memory and
`executable by the processor. The loading engine is operable
`to automatically create object links between corresponding
`input variables and output variables of each of the plurality
`of objects. The system may also include an update engine
`residing in the memory and executable by the processor. The
`update engine is operable to sequentially update each of the
`plurality of objects to obtain an output variable value for
`each of the plurality of objects.
`
`FR
`
`2 689 260
`
`10/1993
`
`......... G05B/19/403
`
`31 Claims, 5 Drawing Sheets
`
`60
`~
`
`62
`
`PARENT OBJECT
`
`

`

`Case 1:21-cv-00227-UNA Document 1-4 Filed 02/18/21 Page 3 of 17 PageID #: 96
`
`U.S. Patent
`
`Jan.27,2004
`
`Sheet 1 of 5
`
`US 6,684,220 Bl
`
`FIG. 1
`
`10
`✓
`
`20
`
`18
`
`MEMORY
`
`30
`\
`LOADING ENGINE
`
`32
`\
`UPDATE ENGINE
`
`REPORTING ENGINE
`
`34
`
`16
`
`OUTPUT DEVICE
`
`PROCESSOR
`
`12
`
`INPUT DEVICE
`
`INFORMATION SOURCE
`
`MODEL LIBRARY
`I
`
`I
`
`MODELS
`
`I
`
`]
`
`1 ~BJ\CTS 1J
`
`44
`
`40
`
`-
`-
`I'\. 42
`
`INDENTIFIER
`VARIABLE
`DATABASE
`\
`50
`
`INTERFACE APPLICATION
`
`14
`
`36
`
`60
`~
`
`64
`
`CONTAINER
`OBJECT
`
`FIG. 2
`
`62
`
`PARENT OBJECT
`
`

`

`Case 1:21-cv-00227-UNA Document 1-4 Filed 02/18/21 Page 4 of 17 PageID #: 97
`
`70
`~
`
`FIG. 3
`
`72
`
`)
`
`82
`__l_
`I TABLE I 92
`I TEMPERATURE) I
`
`OBJECT
`
`l
`
`90
`
`ALTITUDE
`
`)
`
`ATMOSPHERE OBJECT
`
`86
`88
`I
`98 I rum,11u1~ 1 102 106 I FUNCTION
`
`OBJECT
`
`nn ,rr.T
`
`I
`
`)
`
`I 76
`I TEMPERATUR9
`I
`I
`
`I
`
`I
`
`I
`
`74---1
`
`ALTITUDE /--1
`
`FUNCTION
`OBJECT
`
`ALTITUDE ')
`
`PRESSURE
`
`94
`
`(
`84
`
`96
`
`I
`~ ~ 1---~·-'-
`I-·-···'-
`I DELT<' DEL~ I"' T"'
`I PRESSURE /
`11 o
`?
`I
`\
`I
`104 108
`100
`
`78
`
`PRESSURE ,
`I 80
`
`d •
`r:JJ.
`•
`~
`......
`~
`~ =
`......
`
`~
`~
`?
`N
`~-..J
`N
`0
`0
`,i;;..
`
`~
`~
`
`'JJ. =-
`....
`N
`....,
`0
`Ul
`
`e
`r.,J.
`_,.a-...
`a-...
`~
`,I;;..
`'N
`N
`Q
`~
`i,-
`
`

`

`Case 1:21-cv-00227-UNA Document 1-4 Filed 02/18/21 Page 5 of 17 PageID #: 98
`
`U.S. Patent
`
`Jan.27,2004
`
`Sheet 3 of 5
`
`US 6,684,220 Bl
`
`START
`
`IDENTIFY INPUT VARIABLES AND
`OUTPUT VARIABLES FOR CONTAINER
`OBJECTS OF PARENT OBJECT
`
`SELECT A CONTAINER OBJECT
`
`IDENTIFY INPUT VARIABLE
`OF CONTAINER OBJECT
`
`DETERMINE WHETHER INPUT VARIABLE
`OF CONTAINER OBJECT IS AN
`INPUT VARIABLE OF PARENT OBJECT
`
`400
`
`402
`
`404
`
`406
`
`FIG. 4A
`410
`
`INPUT
`DETERMINE WHETHER
`VARIABLE
`IS AN OUTPUT VARIABLE
`OF ANOTHER CONTAINER OBJECT
`
`V
`T
`
`YES
`
`416
`
`NO
`
`DETERMINE WHETHER OBJECT LINK
`EXISTS BETWEEN CORRESPONDING
`INPUT AND OUTPUT VARIABLES
`
`YES
`
`CONNECT INPUT VARIABLE OF
`PARENT OBJECT TO CORRESPONDING
`INPUT VARIABLE OF
`CONTAINER OBJECT
`
`422
`
`DETERMINE WHETHER ADDITIONAL
`INPUT VARIABLES EXIST FOR
`CONTAINER OBJECT
`
`420
`
`INPUT VARIABLE OF
`CONNECT
`THE CONTAINER OBJECT TO THE
`CORRESPONDING OUTPUT VARIABLE
`
`DETERMINE WHETHER OUTPUT
`VARIABLE OF CONTAINER
`OBJECT IS OUTPUT VARIABLE
`OF PARENT OBJECT
`
`YES
`
`FROM
`FIG. 4B
`
`IDENTIFY OUTPUT VARIABLE
`OF CONTAINER OBJECT
`
`428
`
`TO
`FIG. 4B
`
`

`

`Case 1:21-cv-00227-UNA Document 1-4 Filed 02/18/21 Page 6 of 17 PageID #: 99
`
`U.S. Patent
`
`Jan.27,2004
`
`Sheet 4 of 5
`
`US 6,684,220 Bl
`
`FIG. 4B
`
`FROM
`FIG. 4A
`
`434
`
`CONNECT OUTPUT VARIABLE OF
`PARENT OBJECT TO CORRESPONDING
`OUTPUT VARIABLE OF
`CONTAINER OBJECT
`
`454
`
`DETERMINE WHETHER ADDITIONAL
`OUTPUT VARIABLES EXIST FOR
`CONTAINER OBJECT
`
`FROM
`FIG. 4A
`
`DETERMINE WHETHER OUTPUT
`VARIABLE OF CONTAINER OBJECT
`IS INPUT VARIABLE OF ANOTHER
`CONTAINER OBJECT
`
`436
`
`NO
`
`440
`
`TRANSMIT
`ALARM SIGNAL
`
`IDENTIFY CORRESPONDING INPUT
`VARIABLE OF CONTAINER OBJECT
`
`DETERMINE WHETHER OUTPUT
`VARIABLE
`IS ALREADY CONNECTED
`TO CORRESPONDING
`INPUT
`VARIABLE OF CONTAINER OBJECT
`
`442
`
`444
`
`448
`
`450
`
`TO
`FIG. 4A
`
`DETERMINE WHETHER ADDITIONAL
`CONTAINER OBJECTS EXIST IN
`PARENT OBJECT
`
`CONNECT OUTPUT VARIABLE TO
`CORRESPONDING INPUT VARIABLE
`OF CONTAINER OBJECT
`
`DETERMINE WHETHER OUTPUT
`VARIABLE
`IS INPUT VARIABLE OF
`ANOTHER CONTAINER OBJECT
`
`SELECT NEXT CONTAINER OBJECT
`
`462
`
`TO
`FIG. 4A
`
`YES
`
`

`

`Case 1:21-cv-00227-UNA Document 1-4 Filed 02/18/21 Page 7 of 17 PageID #: 100
`
`U.S. Patent
`
`Jan.27,2004
`
`Sheet 5 of 5
`
`US 6,684,220 Bl
`
`START
`
`IDENTIFY OUTPUT VARIABLE FOR PARENT OBJECT
`
`500
`
`IDENTIFY CONTAINER OBJECT FOR PROVIDING
`THE OUTPUT VARIABLE VALUE
`
`so2 FIG. 5
`
`IDENTIFY INPUT VARIABLE OF CONTAINER OBJECT
`REQUIRED TO UPDATE CONTAINER OBJECT
`
`INPUT VARIABLE VALUE
`DETERMINE WHETHER
`OF CONTAINER OBJECT IS KNOWN
`
`504
`
`506
`
`NO
`
`510
`
`INPUT
`DETERMINE WHETHER ANOTHER
`VARIABLE OF CONTAINER OBJECT IS REQUIRED
`FOR UPDATING CONTAINER OBJECT
`
`IDENTIFY THE CONTAINER
`OBJECT FOR PROVIDING
`THE
`INPUT VARIABLE VALUE
`
`512
`
`UPDATE CONTAINER OBJECT
`
`DETERMINE OUTPUT VARIABLE VALUE
`
`OUTPUT THE OUTPUT VARIABLE
`VALUE FOR THE PARENT OBJECT
`
`DETERMINE WHETHER ANOTHER OUTPUT
`VARIABLE FOR PARENT OBJECT EXISTS
`
`516
`
`518
`
`520
`
`522
`
`YES
`
`

`

`Case 1:21-cv-00227-UNA Document 1-4 Filed 02/18/21 Page 8 of 17 PageID #: 101
`
`US 6,684,220 Bl
`
`5
`
`10
`
`2
`The present invention provides several technical advan(cid:173)
`tages. For example, in one embodiment, a loading engine
`automatically links corresponding input variables and output
`variables of the objects of a model, thereby alleviating a
`requirement to manually create object links between the
`corresponding input variables and output variables of each
`of the model objects. Accordingly, users of the system need
`not know whether the data is in the form of a table or some
`combination of tables and functions.
`Another technical advantage of the present invention
`includes sequentially updating each of the objects of the
`model to obtain output variable values while substantially
`eliminating duplicate object updates and redundant calcula(cid:173)
`tions. For example, in one embodiment, the system includes
`15 an update engine that sequentially updates each of the model
`objects as an output variable value of the object is required,
`thereby substantially eliminating redundant calculations and
`providing consistency of output variable values of the
`model.
`Other technical advantages of the present invention will
`be readily apparent to one skilled in the art from the
`following figures, descriptions, and claims.
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`1
`METHOD AND SYSTEM FOR AUTOMATIC
`INFORMATION EXCHANGE
`
`TECHNICAL FIELD OF THE INVENTION
`
`The present invention relates generally to the field of
`information processing in a computer system and, more
`particularly, to a method and system for automatic informa(cid:173)
`tion exchange.
`
`BACKGROUND OF THE INVENTION
`
`SUMMARY OF THE INVENTION
`
`Information is often exchanged between tools or applica(cid:173)
`tions in a computer system and between groups of persons
`or employees within an organization. The information may
`include data, such as alphanumeric values, tables, and analy(cid:173)
`sis data. For example, the data may define numerical rela(cid:173)
`tionships between independent and dependent variables in
`either tabular or functional form. The information may also
`include methods, such as tabular information, interpolation 20
`and extrapolation methodologies, and functional
`information, such as equations, intrinsics, and logic. For
`example, the methods may generally include the operations
`used to compute dependent variable values given indepen(cid:173)
`dent variable values including the mechanics of interpola- 25
`tion and extrapolation.
`However, because most tools or applications are written
`to use unique file formats and data structures, translation of
`both the data and the methods used to manipulate the data is
`generally required to accommodate an exchange of the
`information. Additionally, exchanging information between
`applications and groups is further aggravated by heterog(cid:173)
`enous computing environments. Thus, considerable amounts
`of effort and time are required to reformat and restructure the
`data and the methods prior to efficiently using the exchanged
`data and methods.
`
`For a more complete understanding of the present
`invention, and the advantages thereof, reference is now
`made to the following description taken in conjunction with
`the accompanying drawings, wherein like reference numer-
`30 als represent like parts, in which:
`FIG. 1 is a block diagram illustrating a system for
`automatic information exchange in accordance with one
`embodiment of the present invention;
`FIG. 2 is a block diagram illustrating a model of the
`35 system illustrated in FIG. 1 in accordance with an embodi(cid:173)
`ment of the present invention;
`FIG. 3 is a block diagram illustrating another model of the
`system illustrated in FIG. 1 in accordance with an embodi(cid:173)
`ment of the present invention;
`FIGS. 4A and 4B are flow diagrams illustrating a method
`for automatic model object linking in accordance with an
`embodiment of the present invention; and
`FIG. 5 is a flow diagram illustrating a method for updating
`45 model objects in accordance with an embodiment of the
`present invention.
`
`40
`
`DETAILED DESCRIPTION OF THE
`INVENTION
`FIG. 1 is a block diagram illustrating a system 10 for
`automatic information exchange in accordance with one
`embodiment of the present invention. It will be understood
`that system 10 may be otherwise configured within the scope
`of the present invention. For example, system 10 may
`operate as a stand alone system or may be connected to a
`server system or other type of computing system.
`In the embodiment illustrated in FIG. 1, system 10
`comprises a processor 12, an input device 14, an output
`device 16, a memory 18, and an information source 20. The
`60 present invention also encompasses computer software that
`may be stored in memory 18 and executed by processor 12.
`The computer software may also be stored in a variety of
`other types of storage media including, but not limited to,
`floppy disk drives, hard drives, CD ROM disk drives, or
`65 magnetic tape drives. Information, such as variable value
`data or other types of data, may be received from a user of
`system 10 using a keyboard or any other type of input device
`
`Accordingly, a need has arisen for an improved system
`and method for the efficient exchange and utilization of
`information between computer systems and groups of per(cid:173)
`sons or employees within an organization. The present
`invention provides a method and system for automatic
`information exchange that substantially reduces or elimi(cid:173)
`nates problems associated with prior systems and methods.
`In accordance with an embodiment of the present
`invention, a system for automatic information exchange
`includes a processor and a memory coupled to the processor
`and operable to store a model. The model comprises a 50
`plurality of objects. Each of the plurality of objects com(cid:173)
`prises an input variable and an output variable. The system
`further includes a loading engine residing in the memory and
`executable by the processor. The loading engine is operable
`to automatically create object links between corresponding 55
`input variables and output variables of each of the plurality
`of objects.
`According to another embodiment of the present
`invention, a method for automatic information exchange
`includes receiving a model at a processor. The model
`includes a plurality of objects. Each of the plurality of
`objects includes an input variable and an output variable.
`The method also includes automatically identifying the input
`variables and the output variables of each of the plurality of
`objects. The method further includes automatically creating
`object links between the corresponding input variables and
`output variables of each of the plurality of objects.
`
`

`

`Case 1:21-cv-00227-UNA Document 1-4 Filed 02/18/21 Page 9 of 17 PageID #: 102
`
`US 6,684,220 Bl
`
`3
`14. Output values or results may be output to a user of
`system 10 through output device 16, which may include a
`display, printer, or any other type of output device.
`System 10 includes a loading engine 30, an update engine
`32, a reporting engine 34, and an interface application 36, 5
`which are computer software programs. In FIG. 1, loading
`engine 30, update engine 32, reporting engine 34, and
`interface application 36 are illustrated as being stored in
`memory 18, where they can be executed by processor 12.
`Loading engine 30, update engine 32, reporting engine 34, 10
`and interface application 36 may also be stored on a variety
`of other types of storage media.
`Loading engine 30 processes information from informa(cid:173)
`tion source 20 in preparation for evaluation of the informa(cid:173)
`tion using update engine 32. By way of example, informa- 15
`tion source 20 may comprise a model library 40 having one
`or more models 42 which may be selected by a user of
`system 10 using input device 14. Models 42 each include
`one or more cooperative collections of objects 44 to provide
`a simulation or analysis of selected information. However, 20
`models 42 may be otherwise configured to provide analysis,
`simulation or other user-defined information processing
`parameters.
`Objects 44 generally include data sets, data tables, or
`functions for processing the information according to a 25
`selected model 42. Each object 44 represents an instance of
`some class, and whose classes are all members of a hierar(cid:173)
`chy of classes united via inheritance relationships. Each
`object 44 includes an input variable and an output variable.
`Each object 44 is an identifiable, encapsulated piece of code 30
`and data that provide one or more services when requested
`by a user. Thus, based on an input variable value, the object
`44 provides an output variable value corresponding to the
`table, data set or function of the object 44. Loading engine
`30 automatically creates object links between each of the 35
`input variables and output variables of the objects 44 of a
`selected model 42. As used herein, each means every one of
`at least a subset of the identified objects 44. Additionally, the
`term "automatically" means without further significant user
`action or interaction.
`Information source 20 may also include a variable iden(cid:173)
`tifier database 50 including a unique identifier associated
`with each input variable and output variable of objects 44.
`For example, the unique identifier may include terminology,
`alphanumeric designations, phrases or other suitable iden- 45
`tifiers to identify particular input variables and output vari(cid:173)
`ables of objects 44. The unique identifiers are maintained
`and stored in variable identifier database 50 such that
`loading engine 30 may access variable identifier database 50
`for each object 44 included within a particular model 42 to 50
`automatically determine the input and output variable of the
`object 44 and automatically link corresponding input and
`output variables of the objects 44. However, the input and
`output variables of objects 44 may be otherwise identified
`and stored in variable identifier database 50.
`Update engine 32 processes models 42 and automatically
`updates each object 44 of a model 42 sequentially to obtain
`output variable values of the user-selected model 42 based
`on user-defined input variable values. For example, update
`engine 32 sequentially updates each object 44 of a model 42 60
`to obtain output variable values for each object 44 without
`performing redundant calculations. Thus, a particular object
`44 may be updated when an output variable value of the
`updated object is required to support the update of another
`object 44. The methodology of updating objects 44 using 65
`update engine 32 will be discussed in greater detail below in
`conjunction with FIGS. 3 and 5.
`
`4
`Reporting engine 34 may be used to display output
`variable values of a particular model 42 to a user of system
`10 using output device 16. For example, reporting engine 34
`may provide output variable values in a particular format or
`structure as defined by a user using input device 14.
`However, reporting engine 34 may be otherwise used to
`display or provide output variable values to a user of system
`10.
`Interface application 36 may be used to receive input
`variable values from a user of system 10 using input device
`14 and automatically associate the data or input variable
`values received from the user to corresponding input vari(cid:173)
`ables of objects 44. However, input variable values may be
`otherwise received and associated with the corresponding
`input variables of objects 44.
`FIG. 2 is a block diagram illustrating a model 60 in
`accordance with an embodiment of the present invention.
`Model 60 includes a parent object 62 and container objects
`64 and 66 embedded within parent object 62. Container
`objects 64 and 66 may include a data set object, a function
`object, a table object, or other type of object. Additional
`objects may also be embedded within each container object
`64 and 66. As illustrated in FIG. 2, parent object 62 includes
`input variables A and B and provides output variables X, Y,
`and D. Container object 64 receives values associated with
`input variables A and B and provides output variables X, Y,
`and D. Similarly, container object 66 receives output vari(cid:173)
`ables Y and D from container object 64 and input variable
`C to obtain output variable Z, which is also an output
`variable of parent object 62.
`In operation, the input variables and output variables of
`parent object 62 and container objects 64 and 66 are stored
`in variable identifier database 50. Loading engine 30 is
`executed by processor 12 and automatically creates object
`links between the corresponding input variables and output
`variables of parent object 62 and container objects 64 and
`66. For example, for model 60, loading engine 30 automati(cid:173)
`cally identifies the objects of model 60, in this example,
`40 parent object 62 and container objects 64 and 66. Loading
`engine 30 also automatically identifies the input variables
`and output variables of each object of model 60 to provide
`object links between corresponding input and output vari(cid:173)
`ables.
`For example, parent object 62 may represent a top-level
`object of model 60 such that a user provides input variable
`values for input variables A, B, and C to obtain output
`variable values for output variables X, Y, and Z. Loading
`engine 30 automatically identifies the container objects
`embedded within parent object 62, in this example, con(cid:173)
`tainer objects 64 and 66, and automatically determines
`whether the input variables of parent object 62 correspond to
`an input variable of one of the container objects 64 and 66.
`In the embodiment illustrated in FIG. 2, loading engine 30
`55 automatically creates an object link between input variables
`A and B of parent object 62 and input variables A and B of
`container object 64. Loading engine 30 also automatically
`creates an object link between input variable C of parent
`object 62 and input variable C of container object 66.
`Additionally, loading engine 30 automatically creates
`object links between the container objects 64 and 66 embed(cid:173)
`ded within parent object 62. In the example illustrated in
`FIG. 2, loading engine automatically creates an object link
`between output variables Y and D of container object 64 and
`corresponding input variables Y and D of container object
`66. Loading engine 30 also automatically creates object
`links between output variables X and Y of container object
`
`

`

`Case 1:21-cv-00227-UNA Document 1-4 Filed 02/18/21 Page 10 of 17 PageID #: 103
`
`US 6,684,220 Bl
`
`5
`64 and output variable Z of container object 66 and output
`variables X, Y, and Z of parent object 62. Thus, loading
`engine 30 automatically identifies and creates object links
`between corresponding input variables and output variables
`of the objects comprising model 60, thereby alleviating a
`requirement of manually creating object links between vari(cid:173)
`ous objects of model 60.
`Accordingly, the present invention also provides greater
`ease of replacement and modification of objects 44 within a
`model 42 than prior systems and methods. For example,
`objects 44 may be freely modified or replaced without
`manually creating object links between the modified or
`replaced object 44 and other objects 44 of the model 42
`because loading engine 30 automatically creates the object
`links between the various objects 44 of a model 42.
`Therefore, the present invention accommodates frequent
`object 44 modification and/or replacement.
`FIG. 3 is a block diagram illustrating a model 70 in
`accordance with an embodiment of the present invention. In
`this embodiment, model 70 includes a parent or atmosphere
`object 72 having an input variable 74 and output variables
`76, 78, and 80. Atmosphere object 72 includes a table object
`82 and function objects 84, 86, and 88. Table object 82
`includes an input variable 90 and an output variable 92.
`Function object 84 includes an input variable 94 and an
`output variable 96. Function object 86 includes input vari(cid:173)
`ables 98 and 100 and output variables 102 and 104. Function
`object 88 includes input variables 106 and 108 and an output
`variable 110.
`In the embodiment illustrated in FIG. 3, model 70 pro(cid:173)
`vides a user of system 10 with various output variable
`values, for example, flight envelope data, in response to
`particular input data or input variable values. For example,
`input variable 74 of atmosphere object 72 may include an
`altitude value for an aircraft flight envelope. Table object 82
`receives the altitude value as input variable 90 and provides
`a temperature value as output variable 92. The temperature
`value provided by output variable 92 is also output as output
`variable 76 of atmosphere object 72. Function object 84
`receives the altitude value as input variable 94 and provides
`a pressure value as output variable 96. The pressure value
`provided as output variable 96 is also output to output
`variable 80 of atmosphere object 72.
`Function object 86 receives the temperature value and the
`pressure value as input variables 98 and 100, respectively,
`and provides a theta value and a delta value as output
`variables 102 and 104, respectively. In this embodiment, the
`theta value may represent a temperature ratio as compared to
`a sea level temperature, and the delta value may represent a
`pressure ratio compared to a sea level pressure. Function
`object 88 receives the theta value and the delta value as input
`variables 106 and 108, respectively, and provides a sigma
`value as output variable 110. The sigma value is also output
`as output variable 78 of atmosphere object 72. In this
`embodiment, the sigma value may represent a ratio of the
`theta value and the delta value. Thus, based on a particular
`altitude values as input variable 74, model 70 provides a
`temperature value, a pressure value, and a sigma value as
`output variables 76, 78, and 80, respectively.
`In operation, a user of system 10 may designate or select
`a particular model 42 from model library 40 and/or may also
`modify the objects 44 included within a particular model 42.
`Loading engine 30 automatically identifies the input vari(cid:173)
`ables and the output variables for each object 44 of the
`selected model 42. For example, loading engine 30 may
`access variable identifier database 50 to retrieve and identify
`
`6
`each input variable and output variable of the objects 44 of
`model 42. For example, in connection with FIG. 3, loading
`engine 30 accesses variable identifier database 50 and auto(cid:173)
`matically identifies the input variables and the output vari-
`5 ables for atmosphere object 72, table object 82, and function
`objects 84, 86, and 88.
`Loading engine 30 initially automatically selects one of
`the objects 82, 84, 86 and 88 of atmosphere object 72 to
`create object links between the input variables and output
`10 variables of the objects 82, 84, 86 and 88 and atmosphere
`object 72. For example, loading engine 30 may automati(cid:173)
`cally select table object 82; however, loading engine 30 may
`also automatically select other container objects within
`atmosphere object 72. After selecting table object 82, load-
`15 ing engine 30 automatically identifies input variable 90 of
`table object 82 and automatically determines whether input
`variable 90 is also an input variable of atmosphere object 72.
`In the embodiment illustrated in FIG. 3, input variable 74 is
`also used as input variable 90 of table object 82, therefore,
`20 loading engine 30 automatically creates an object link
`between input variable 74 and input variable 90. Loading
`engine 30 next automatically determines whether additional
`input variables exist for table object 82. In this example, no
`additional input variables exist for table object 82. Because
`25 no additional input variables exist for table object 82,
`loading engine 30 next automatically identifies the output
`variable for table object 82, in this example, output variable
`92.
`After identifying output variable 92 of table object 82,
`30 loading engine 30 automatically determines whether output
`variable 92 of table object 82 is also an output variable of
`atmosphere object 72. In this case, because the temperature
`value of output variable 92 is also output variable 76 of
`atmosphere object 72, loading engine 30 automatically
`35 creates an object link between output variable 76 of atmo(cid:173)
`sphere object 72 and output variable 92 of table object 82.
`Loading engine 30 next automatically determines whether
`additional output variables exist for table object 82. In this
`example, because no additional output variables exist for
`40 table object 82, loading engine 30 next automatically deter(cid:173)
`mines whether additional container objects are embedded
`within atmosphere object 72.
`Loading engine 30 next automatically selects another
`container object within atmosphere object 72, for example,
`45 function object 84. Loading engine 30 automatically iden(cid:173)
`tifies the input variable for function object 84 and automati(cid:173)
`cally determines whether the input variable for function
`object 84 is also the input variable for atmosphere object 72.
`In this example, because the altitude value input to atmo-
`50 sphere object 72 is also used as an input variable value for
`function object 84, loading engine 30 automatically creates
`an object link between input variable 74 of atmosphere
`object 72 and input variable 94 of function object 84.
`Loading engine 30 next automatically determines whether
`55 additional input variables exist for function object 84. In this
`example, because no additional input variables exist for
`function object 84, loading engine 30 next automatically
`identifies the output variables for function object 84. Load(cid:173)
`ing engine 30 automatically identifies output variable 96 of
`60 function object 84 and automatically determines whether
`output variable 96 is also an output variable of atmosphere
`object 72. In this example, because the pressure value
`provided by function object 84 is also an output variable
`value of atmosphere object 72, loading engine 30 automati-
`65 cally creates an object link between output variable 80 of
`atmosphere object 72 and output variable 96 of function
`object 84.
`
`

`

`Case 1:21-cv-00227-UNA Document 1-4 Filed 02/18/21 Page 11 of 17 PageID #: 104
`
`US 6,684,220 Bl
`
`5
`
`10
`
`7
`Loading engine 30 next automatically determines whether
`additional output variables exist for function object 84. In
`this example, because no additional output variables exist
`for function object 84, loading engine 30 next automatically
`determines whether additional container objects are embed-
`ded within atmosphere object 72 and, if additional container
`objects are embedded within atmosphere object 72, auto(cid:173)
`matically selects another one of the container objects
`embedded within atmosphere object 72, for example, func(cid:173)
`tion object 86.
`After selecting function object 86, loading engine 30
`automatically identifies an input variable for function object
`86, for example, input variable 98, and automatically deter(cid:173)
`mines whether input variable 98 is also an input variable of
`atmosphere object 72. In this example, as illustrated in FIG. 15
`3, because input variable 98 is not an input variable to
`atmosphere object 72, loading engine 30 next automatically
`queries other container objects within atmosphere object 72
`at the same object level as function object 86, often referred
`to as sibling objects, to determine whether input variable 98 20
`is an output variable of a sibling container object embedded
`within atmosphere object 72. If loading engine 30 does not
`locate a corresponding output variable of another container
`object within atmosphere object 72 to provide a value for
`input variable 98, loading engine 30 may automatically 25
`transmit an alarm or warning signal to the user of system 10
`indicating that input variable 98 does not have an associated
`object link, thereby indicating to the user that the model
`requires modification.
`In the embodiment illustrated in FIG. 3, loading engine 30 30
`automatically identifies output variable 92 of table object 82
`as corresponding to input variable 98 of function object 86.
`For example, because the input and output variables have
`been assigned unique identifiers and stored in variable
`identifier database 50, loading engine 30 automatically 35
`accesses variable identifier database 50 to determine corre(cid:173)
`sponding input and output vari