CA2358401C - Systems for generating and using a lookup table with process facility control systems and models of the same, and methods of operating such systems - Google Patents

Abstract

Systems and methods of operating the same are introduced for populating and using lookup tables with process facility control systems and models of the same. An exemplary computer system for use with a process facility having a plurality of associated processes, and includes both a memory and a processor.
The memory is capable of maintaining (i) a data structure having a plurality of accessible fields and (ii) a model of at least a portion of the plurality of associated processes. The model may include a mathematical representation of at least a portion of the at least one process, defining certain relationships among inputs and outputs of the at least one process. The processor is capable of populating ones of the plurality of accessible fields of the data structure using the model iteratively with a range of possible values of the at least one measurable characteristic. The computer system is capable of using the range of possible values of the at least one measurable characteristic to predict an unforced response associated with the at least one process.

Description

SYSTEMS FOR GFNERATING AND USING A LOOM TABLE WITH
PROCESS FACXLITY CONTROL SYSTEMS AND MODELS OF THE SAME, AND METHODS OF OPERATING SUCH SYSTEMS

s COPMGHT NOTICE
A porttion of the disclosure of this patent document (softwara listings in APPEvnICEs A and B) ca-ntains mateial that is subjcct to copyright protection.
The copyright owner has no objection to the facsinaile reproduction by anyone of this patent document or the patmi disclosare, as it appears in the United States Patent and Tzaderrxaxk Office patent $1e or records, but otherwise reserves all copyright rights and protection whatsoever.

CROSS-ItEFERTNCE TO BEI A'I'FD PATENT DOC15IENTS
The present invention is related to that disclosed in (i) United States Patant No.
13 5,351,184 entitled NMFTHOD OF MULTIVARIABLE PREDICPIVE COTITROL UTILIZING
RANGE COmRoL;' (ii) United States Patent No. 5,561,599 enti-tled "MBTHoD OF
INOORPORATING INDEPENDENT FEEDFORWARD CONTROi. IN A MULTIVARIABI.E
PREOtCTtvE CONrROLLER;" (iii) United States Pgtent No. 5,574,638 catitled "MzrHOD
OF OPTIMAL SCALING OF VARIABLES IN A MULTIVARIABLe PREDJCTIVFs CONTROLLER
UTi1dZING RANGE CONTROL; " (iv) United Staxes Patent No_ 5,572.420 cutitled "METHOD OF OPTIMAL CONTROLLER DESiGN Olt MULTIVARIABLE PREDICfIV6 CONTROL
ITI'ILLZaNG RANGC CONTROL" (the "`420 Patettt"); (v) Umitted States Patent No.
5,758,047 entitled '1NtETHoo oF PRocEss CorrntoLl.a OrnMI2AMON nN . A
MuLTIvARrAaLE PREDtcrivE CoNTRoLLER; " (vi) United States Patent No. 5,758.047, filed on aune 14, 1995. entitled "Method of Process Controller Optimization in a Multivariable Predictive Controller;" (vii) United Statcs Patent No. 6,122,555 enatled "SYsTrms Arro Mrmons FoR GLoaALLY
OPTIMiZING A PROCESS FACILITY;" (viii) Uritea StBfts Patent Applicata=&OW"No.
08\e5+,49e entitled SYST6MS FOR GENERAT7NG AND USINC3 A I.oOKuP TABLE wiTH
PROCSSS FACILTrY CONTROL SYSTBMS AND MODBI.S OF THE SAME, AND ME7'b10DS OF
OPERATING SUCH SYSTEMS;" and ('ix) Uactitcd States Patcat Application No.
6,253,113 MdtlCd "CON'TROLLERB THAT DETERMINE OPTIMAL T1JNING PARAMETERS
FOR USE IN PROCESS CONTROL SYSTEMS AND METHODS OF OPERATING THE SAME;" and (x) United States Patent No. 6,347,254 e1Rt7Utled "PROCSSS FACiL1TY CONTROL SYSTEMS USNNti AN EFFICIENT PREDlCT1ON
FORM
AND 1VIETHODs OF OPEtATrNC THE SAMt" (which application is filed concurrently herewith), all of which are commonly assigned to the assigncc of thc presont invention.

The presem invention is dirccticd, in general, to coatrol systems for process facilities and, more specifieally, to systems for generating and using lookup tables with process facility control systems and models of the same, and methods of operating such systcrns, all for use to optimize process faailities.

BACKGROUND O.F THE TNVFN't'TON
Presently, process facilities (e.g., amanufacturing plant, a miuera! or crtide oil ref nery, ctc.) are managed using distributed contxol syscems. Contemporary contral systems include numerous modvJes tailored to control or monitor various associated processcs of the facility. Conventional means link these modules together to produce the distributed taature of the commi system. This affords increased perfonnance and a capability to expand or reduce the control system to satisfy changing facility meods.
proeess racilitiy xna~nagemcnt providexs, sucb as HoNSVwELL, INC., develop control systcros that can be tailored to satisfy wide ranges of process rcquirements (e.g., global, local or otherwise) and facility rypcs (e,g., manufaaturing, refmi.ng, etc.). A
priuiary objccuve of such providera is to eeatralize eontrol of as many processcs as poesible to improve an overall efficiency of tlu facility. Eaoh process, or group of associated processes, has eertain input (e.g:, flow, feed, power, etc.) and output (e.g., temperature, pressiure, etc.) cbaracteristies associated with it, In recent years, model predictive control ("MPC") techniques have becn used to optimize certain proeesses as a function of such characteristics. One technique uses algorithmic represcutations to estimate characteristic values (repnasented as paramebGrs.
variables, etc.) associated with them that can be used to better oontrol such processes.
In rnccnt years, physical, econoalio and other factors have been incarporatcd isato control systatns for these associated procemimm Examples of such techniques are described in i7nitcd States Patent No. 5,351,184 entitled "METHob OF
MUI,TivARtABI.E
ftwScTrvE CoNntoL UTit.iziNc; RANGE CoNiRol.;" United States Patent No.

5,561,599 entitled "METHOD OF INCORPORATtNG INDEPBNDENT FEEDFORWARD
CONTROL IN A MULTIVARIABI.E PREDtCCY'!VE CONTROLLER;" United States Patent No.
5,574,638 entitled `METHOD OF OPTIMAL SCALING OF VARIABLES tN A MULTIVARIABLE
PREDlCTIVE CONTROLLER UTIWZING RANC3E CONTROL;" United States Patent No.
5,572,420 entitled "METHOD OF OPT[MAL CONTROLLER DESiGN OF MULnvARZASLE
pREDiCT1VE CONTROL UTILIZiNG RANGE CONTROL" (the 111420 Patant); United States Patent No. 6,122,555 entitled "SYSTEMS AND METHons FoR
QLOSAU.Y 0p'nM1zI~rtc A PRocEss Fa.carrY:' United States Patent No. 6,055,483 entitled "SYs'TEMS AND MriTHODS USING BRIDGE MODELS TO
OLOBALLY OPTIMIZE A PROcfiSS FACILIT1f;" and United States Patent No. 6,253,113 crttitted "CONTROLLERS THAT DETERMnvE OP7'TMAL 'huNmvc PARAMETERS FOR USE iN PROCESS CONTROL SYS7'EMS AND MBl"HODS oF OPERAT]NG
7HE SAME' :

is Generally spcoking, ome problem is that conventiosaal. effoits, when applied to spccific p:ooesses, tend to be non-cooperative (e.g, non global, non-facility wide, etc.) and may, and all too oflen do, detrimentally impact the efficiency of the process facility as a whole. For irormace, mmy MPC techniques control proeess variables to predetermined set points. Oftentimes the set points are a best estimstc of a value of the .20 set point or set points. when a process is beirg controlled to a set point, the controller may not be able to achieve the best control perfornaance.s, especially under process/model mismatch.
To furthcr enhance the vverall perforrnsace of a control systern, it is dcsirable to design a controller that deals explicitly with plant or model unaettaisty. The `420 25 Patent, for example, teaahcs methods of desigaing a cmmller utlli.dng rauge control.
The controller is designed to control a "worst case" process. An optimal controller for the process is achieved and, if the actual process is not a`wvarst case process," the performance of the controller is better than anticipated.
Theze am a numbcr of well known PII? "nming" forenui.as, or tectmiques, and 30 thc most common, or basic, PiD algorithm imludes three knorem user specified tuaing paraazeters (K, tiõ T,) whosc values dCtermine how the eontroller will bebave.
1hese pamme'bers are detecmiaeal eitlser by trial and error or throuEh approaches that require knowledge of the process. Ahhough many of these approaches, which are comrnonly algoritbms, hsve provided improved control. PID controller perfonnance wnled by such algorithms usually degrades as process conditions change, requiring a process engineer, or operator, to monitor controller performance. If controller performance deteriorates, the process engineer is required to "re-tune" the controller.
Controller performance deteriorates for many reasons, although the most common cause is changing dynamics of the process. Since PID controller performance has been related to the accuracy of the process model chosen, a need exists for PID
controllers that allows for such uncertainty by accounting for changing system dynamics. Further, the requirement for ever-higher performance control systems demands that system hardware maximize software performance. Conventional control system architectures are made up of three primary components: (i) a processor, (ii) a system memory and (iii) one or more input/output devices. The processor controls the system memory and the input/output ("I/O") devices. The system memory stores not only data, but~also instructions that the processor is capable of retrieving and executing to cause the control system to perform one or more desired functions. The I/O
devices are operative to interact with an operator through a graphical user interface, and with the facility as a whole through a network portal device and a process interface.
Over the years, the quest for ever-increasing process control system speeds has followed different directions. One approach to improve control system performance is to increase the rate of the clock that drives the system hardware. As the clock rate increases, however, the system hardware's power consumption and temperature also increase. Increased power consumption is expensive and high circuit temperatures may damage the process control system. Further, system hardware clock rate may not increase beyond a threshold physical speed at which signals may be processed.
More simply stated, there is a practical maximum to the clock rate that is acceptable to conventional system hardware.
An alternate approach to improve process control system performance is to increase the number of instructions executed per clock cycle by the system processor ("processor throughput"). One technique for increasing processor throughput calls for the processor to be divided into separate processing stages. Instructions are processed in an "assembly line" fashion in the processing stages. Each processing stage is optimized to perform a particular processing function, thereby causing the processor as a whole to become faster. There is again a practical maximum to the clock rate that is acceptable to conventional system hardware.
Since there are discernable physical limitations to which conventional system hardware may be utilized, a need exists broadly for an approach that decreases the number of instructions required to preform the functions of the process control system.
A need exists for such an approach that accounts for process uncertainty by accounting for changing process dynamics.

SUMMARY OF THE INVENTION
To address the above-discussed deficiencies of the prior art, it is a primary object of the present invention to provide systems and methods of operating such systems for populating and using lookup tables with process facility control systems, as well as models of the same. In accordance with an exemplary embodiment below-discussed, the principles of the present invention may be used to define and populate a lookup table in response to the needs of a global controller. The lookup table is populated with a range of possible values of at least one measurable characteristic associated with one or more processes of the process facility and in accordance with a model of at least a portion of the same.

Rather than calculate and re-calculate certain characteristics associated with a process or process model, which would consume significant system resources, the present invention introduces a data structure capable of maintaining a range of possible values of one or more of such certain characteristics. Use of the lookup table in lieu of execution and re-execution of the instructions for performing characteristic calculations decreases the number of instructions required to preform the functions of the process control system. The lookup table, once suitably populated, accounts for process uncertainty by maintaining the range of possible values, thereby accounting for changing process dynamics.
An exemplary computer system for use with a process facility that is capable of populating a data structure in accordance with the principles of the present invention includes both a memory and a processor. The memory is capable of maintaining (i) the data structure, which has a plurality of accessible fields, and (ii) a model of at least a portion of at least one process of a plurality of associated processes of the process facility. The model may advantageously include a mathematical representation of at least a portion of the at least one process, defining certain relationships among inputs and outputs of the at least one process. The processor is capable of populating ones of the plurality of accessible fields of the data structure using the model iteratively with a range of possible values of the at least one measurable characteristic. The computer system is capable of using the range of possible values of the at least one measurable characteristic to predict an unforced response associated with the at least one process.
In accordance with an important aspect hereof, the data structure may be populated and maintained on-line (e.g., at a controller, distributed through a process control system, etc.), off-line (e.g., standalone computer, computer network, etc.), or through some suitable combination of the same. Likewise, the data structure may remain static upon population, be dynamic, or be modifiable, at least in part.
Those skilled in the art will understand that "controllers" may be implemented in hardware, software, or firmware, or some suitable combination of the same, and, in general, that the use of computing systems in control systems for process facilities is known. The phrase "associated with" and derivatives thereof, as used herein, may mean to include, be included within, interconnect with, contain, be contained within, connect to or with, couple to or with, be communicable with, cooperate with, interleave, be a property of, be bound to or with, have, have a property of, or the like; the term "include" and derivatives thereof, as used herein, are defined broadly, meaning inclusion without limitation; and the term "or," as used herein, means and/or.
The foregoing has outlined rather broadly the features and technical advantages of the present invention so that those skilled in the art may better understand the detailed description of the invention that follows. Additional features and advantages of the invention will be described hereinafter that form the subject of the claims of the invention. Those skilled in the art should appreciate that they may readily use the conception and the specific embodiment disclosed as a basis for modifying or designing other structures for carrying out the same purposes of the present invention.
Those skilled in the art should also realize that such equivalent constructions do not depart from the spirit and scope of the invention in its broadest form.

BRIEF DESCRIPTION OF THE DRAWINGS
For a more complete understanding of the present invention, and the advantages thereof, reference is now made to the following descriptions taken in conjunction with the accompanying drawings, wherein like numbers designate like objects, and in which:
FIGURE l a illustrates a simple block diagram of an exemplary process facility with which the present invention may be used;

FIGURE lb illustrates a detailed block diagram of one of the exemplary local controllers introduced in FIGURE 1 a;

FIGURE 2 illustrates a flow diagram of an exemplary method for populating a data structure in accordance with the principles of the present invention; and FIGURE 3 illustrates an exemplary two-dimensional graphical representation of MV and PV curves in accordance with the principles of the present invention.

DETAILED DESCRIPTION OF THE DRAWINGS
In accordance with the above-given summary, computer systems, and methods of operating the same, are introduced herein for populating and using lookup tables with process facility control systems, as well as models of the same. Before undertaking a detailed description of an advantageous embodiment of the present invention, and discussing the various benefits and aspects of the same, it is useful to understand conceptually the operation and control structure of an exemplary process facility.
Initial reference is therefore made to FIGURE la, wherein a simple block diagram of such a process facility (generally designated 100) is illustrated.
Exemplary process facility 100 is operative to process raw materials, and includes a control center 105, six associated processes 110a to 110f that are arranged into three stages and a control system (generally designated 115). The term "include," as well as derivatives thereof, as used throughout this patent document, is defined broadly to mean inclusion without limitation.

Exemplary control center 105 illustrates a central area that is commonly operator manned (not shown) for centrally monitoring and for centrally controlling the three exemplary process stages. A first process stage includes three raw material grinders 110a to 110c that operate to receive a "feed" of raw material core and to grind the same, such as using a pulverizer or grinding wheel, into smaller particles of raw material. The term "or," as it is used throughout this patent document, is inclusive, meaning and/or.
The second process stage includes a washer 110d that operates to receive the ground raw materials and clean the same to remove residue from the first stage. The third process stage includes a pair of separators 110e and 110f that operate to receive the ground and washed raw materials and separate the same, such as into desired minerals and any remaining raw materials. As this process facility is provided for illustrative purposes only and the principles of such are known, further discussion of the same is beyond the scope of this patent document.

Exemplary control system 115 illustratively includes a global controller 120 and six local controllers 125a to 125f, each of which is implemented in software and executable by a suitable conventional computer system (e.g., standalone, network, etc.), such as any of HONEYWELL, INC.'s AM K2LCN, AM K4LCN, AM HMPU, AxM or like systems. Those skilled in the art will understand that such controllers may be implemented in hardware, software, or firmware, or some suitable combination of the same; in general, the use of computing systems in control systems for process facilities is known.
Global controller 120 is associated with each of local controllers 125, directly or indirectly, to allow communication of information between the same. The phrase "associated with" and derivatives thereof, as used throughout this patent document, may mean to include within, interconnect with, contain, be contained within, connect to or with, couple to or with, be communicable with, cooperate with, interleave, be a property of, be bound to or with, have, have a property of, or the like.
Global controller 120 monitors measurable characteristics (e.g., status, temperature, utilization, efficiency, cost and other economic factors, etc.) of associated processes 110, either directly or indirectly (as shown, through local controllers 125 associated with processes 110). Depending upon the implementation, such monitoring may be of an individual process, group of processes, the facility as a whole, or otherwise. Similarly, local controllers 125 monitor associated processes 110, and, more particularly, monitor certain characteristics of associated processes 110.
Global controller 120 generates, in response to such monitoring efforts, control data that may be communicated via local controllers 125 to associated processes 110 to optimize process facility 100. The phrase "control data," as used herein, is defined as any numeric, qualitative or other value generated by global controller 120 to globally control (e.g., direct, manage, modify, recommend to, regulate, suggest to, supervise, cooperate, etc.) a particular process, a group of processes, a facility, a process stage, a group of process stages, a sequence of processes or process stages, or the like to optimize the facility. Local controllers 125 operate to varying degrees in accordance with the control data to control the associated processes, and, more particularly, to modify one or more processes and improve the monitored characteristics and the facility.

According to an advantageous embodiment, the control data may be dynamically generated using a lookup table defined and populated in accordance with the principles hereof, and such control data generation is based, at least in part, upon a given facility's efficiency, production or economic cost, and, most preferably, all three.

The lookup table may be populated and maintained on-line (e.g., at global controller 120, at local controller 125, distributed within control system 115, etc.), off-line (e.g., standalone computer, network computer, etc.), or through some suitable combination of the same; likewise, the lookup table may be static upon population, be dynamic, or be modifiable, at least in part.

The global controller 120 and the local controllers 125 may suitably use one or more such lookup tables to control processes I 10 to conserve processing resources and increase the overall speed of control system 115. Control system 115 achieves a high level of both global and local monitoring, and cooperative control of associated processes 110 among controllers 120 and 125, by allowing the local controllers 125 to vary their individual or respective compliance with the control data. Varying degrees of compliance by local controllers 125 may range between full compliance and noncompliance. The relationship between global controller 120 and various ones of local controllers 110 may be master-slave (full compliance), cooperative (varying compliance, e.g., using control data as a factor in controlling the associated processes), complete disregard (noncompliance), as well as anywhere along that range.
Depending upon the implementation and needs of a given facility, the relationship between global controller 120 and specific local controllers 125 may be static ( i.e., always only one of compliance, cooperative, or noncompliance), dynamic (i.e., varying over time, such as within a range between compliance and noncompliance, some lesser range therebetween, or otherwise), or varying between the same.
One or more specific processes 110, and facility 100 as a whole, may be dynamically and cooperatively controlled as a function of local and global optimization efforts, and such dynamic and cooperative control is independent of the relationship between global controller 120 and specific local controllers 125, as described above.
Turning to FIGURE lb, illustrated is a more detailed block diagram of one of the exemplary local controllers 125 that is associated with one or group of associated processes 110. Local controller 125 uses a single loop model predictive control ("SL-MPC") structure that uses an efficient matrix prediction form in accordance with the principles of the present invention, as well as an analytical control solution map to reduce utilization of processing resources relative to conventional MPC
technology.
According to the illustrated embodiment, local controller 125 receives as inputs, control/optimization specifications 130 (e.g., bounds, ranges, tolerances, control points, etc.) and feedback data 135 (e.g., output of associated process 110).

Control/optimization spccifications 130 may be received from any of a number of Fources depending upon the associated process or group of associated processes 110, an associated process facility or any other factor. For example, any of control/optimization specifications 130 may be received from an operator of a control center for the associatcd proccss facility, retricvcd from a database or data repositoty, received from another associated controller (e. g, one or ntore local controllers 125, global controlicr 120, or a suitablc combination thcreof). etc.
Control/optimiaation specifications 130 include two types of variables: (1) a first variablc ("MV") that may be manipulated, such as flow, feed, air blower, ete;
and (2) a second variable ("DV") that cannot be manipulated and is a disturbance variable, such as burn rate, f'tlel quality per unit, eLc. Fccdback data 135 is a third variable ("CV") that is responsive to MVs and DVs, and is an output of associated process 110, such as pressute, temperature, etc. A sub-variable ("PV") of Feedback data 135 is indicative of the iteraiave response of the associated process 110 to monitoring and control by the local controller 125. Many, if not all. of such MVs, DVs and CVs t^epresent xneasurable characteristics of associated process 110 that may be suitably monitored by local co:mollcr 125.
Local controller 125 includes a dynamic prediction task with state estimation 150, a local linear program/quadratic program ("LP/QP'I optimization task 155, a dynatnic cantrol//optimiaation augmented range control algorithm ("RCA"} 160 and a lookup table 165. Eaccmplary dynamic prediction task 150 receives CVs and operates to generate an array of multiple predictions (or dynamic unforced predictions) and, at 5 tau (responsc time closc to end), an unforced prediction for values assoeiated with associated process 110. The CVs represent feedback data 135 (e.g., inputs, outputs, etc.) associated with process 105, and dynamic predietaon task 150 operrazes to accesses lookup table 165 and selects one or more values fro=n the range of possible values, such selection being responsive, at least in part, to tbie received feedback data 135_ A
preferred method of using data stcuctures, such as lookup table 165, or functionally equivalent dedicated circufty, to maintain a range of possible values for ome or more so measurable characteristics assoeiated with a process is disolosed and described in United States Patent No. 6,347,254, entitled "PROCESS FACILrrY CONTROI. SYSTEMs USING AN EFFICIENT PREDICTION FORM AND
Mm'HODs OF OPERATING THE SAME" and filed concurrently herewith.

-~~-Exemplary local LP/QP optimiastion task 155 receives optimization specifications 140a and, xn, response to the unforced prediction, operates to genera.te, at tau, optimal values associated with associated process 110.
5 A preferred method of perforlning the foregoing task is disclosed and described in United States Pateat No. 5,758,047, entitled "METHOD OF PRocBss CONTROLLIER
OPTlMIZATIUTI IN A MtJI,T1vAR1A,BLE PREDICTtVE CONCROLLER." wbiCh is CvinmOnly owncd by the assignee of this patent document and related invention,.

Most preferably, optimization specifications 140a are associated, direetty or andiureetly, with an economic value of tha output of associatcd proccss 110.
According to an advantageous embodiment, the unforced prediction may suitably be represented as a single variable and the LP/QP optirnization task may bc a lincar determination of a minimum value or a maximum value, or a quadratic deterrninatioA of Is a desired value. Exemplary dynamic caatrol/optimization augmentod RCA 160 receives control speci$cations 140b and, in respoase to receiving the aaay of multiple pt+edietions (from dynamic prediction task 150) and the optimal values (from local LP/QP op~oa task 1 SS), oparates to genaate control values, the MVs, that are input to associated process 110. An imporant aspect of exempiary local controller 125 is the use of contral/optimiZation specifications 140 and feedback data 135 to locally unify economic/operational optimization with Iv1PC dynamically for a spccific proecss or group of prooesses.
Note the dlsdnctiom between ft foregoing discussion which introducos a vcry poworfvl multi-loop MPC embodiment having a well defined and dynannic iateraerioa/intcrleaviuog relation among global and local controllers and tbc single loop cozttroller ernbodiment described in United Statms Patent No.

6,347,254. Those skilled in the art will understand the relationship among these embodfinents and the applicability of the principles of the present invention.
Turaing now to FIGUItE 2, illusttsied is a flow diagram of an exemplary mcthod (geaerally designated 200) for populating a data structure 165, shown as a lookup table, in accordanee with the principles of the pc+esent ialvention (this discussion of FIGURE 2 xa.akes eoncutrent refixonce to FIGURES la snd lb). 1he phrase "data structure," as the sarne is used herein, is defined broadly as any syntactic stnscture of expressions, daza or other values or indicia, including both logical and physical structures. A data structure may therefore be any array (i.e., any arrangement of objects into one or more dimensions, e.g., a mauix, a table, etc.), or othcr like grouping, organization, or categorization of objects in aocordance herewith.
For purposes of illustiration, a processor 205 and a memory 210 arc introduced.
Exemplary memory 210 is operative to store, or to asaintain, lookup table 165, along with the various tasks/ itastructions (generally designated 215) comprising method 200.
Exempiary processor 205 is operative to select and execute tasks/ instruetions which, in nun, cause processor 205 to perform the functions of method 200.
To begin, processor 205 is directed through the execution of method 200 (e.g., manually (i.e., through interaction with an operator), automatically, or partially-automatically) to define a model 220 of at least a portion of at least one of the associated processes 110 (process stcp 225). Proccssor 205 is directed to store model 220 in memory 210, preferably representing at least a portion of process 110 mathematically. '1"ne mathematical representation defines one or more relationships among inputs and outputs of process 110.
According to an advantageous embodiment, model 220 is defined using the following discrete state space model form:
Xk+1 ~ Axk + B uk (i) yk = Cxk + Duk (2) wherein xb, uk, and yr represent various states of modeled process 110, wherein k is a time peraod and k+l is a ncxt time period, and A, B, C, and I) respectively represent measurable characteristics of modeled procesa 110 at any given time period.
Processor 205 is directed to define a data structure, such as lookup table 165, having a plurality of accessible fields (process step 230). An exemplary source code embodiment for perfomiing this dcf nition is attached as APPENDIX A, and that is written in Pascal. Depeia,aing upon the needs of the particular implcmcntation, the contents of such accessible fields may suitably be nulled, defaulted, or otherwise initialized or used_ Memory 210, directed by processor 205. maintains lookup tablc 165, preferably rc,~presenting, at least in part, an ABOI matrix 235 and a feedback vector 240.

According to an advantageous embodiment, ABOI matrix 235 and feedback vector 240 have the following respective definitions:
A B
0 I(3) xk Uk (4) wherein I and 0 respectively and illustratively represent an identity matrix and an null matrix, for the purpose of this illustrative model, to maintain, or hold, MV
constant (illustrated with respect to FIGURE 3).
Processor 205 is directed to delineate mathematically a relationship among the above-given matrix 235 and vector 240 (process step 245), which according to an advantageous embodiment, has the following form:
A B
Zk+1 0 I Zk Z= xk k uk (s) Processor 205 is directed to delineate mathematically a relationship among the above-given discrete state space model form and the Z vector 240 (process step 250), which, according to an advantageous embodiment, gives the following prediction form for any p interval, or point in the future:
p A Y(k+ p) k=[CD] 0 A I Bzk (6) Stated generally, use of Z vector 240 represents, or defines, mathematically, the relationship among the one or more inputs and outputs of modeled process 110.
For a variety of purposes, as above-stated, for monitoring and for control of process 110, it is desirable to decrease utilization of processing resources.
This may be accomplished, in part, through a recognition that certain characteristics of process 110 are measurable (e.g., appraising, assessing, gauging, valuating, estimating, comparing,,$
computing, rating, grading, synchronizing, analyzing, etc.), whether or not such characteristics are dependent, independent, interdependent, or otherwise effected by other characteristics of the same process, a group of processes, a facility, a process -]4-stage, a group of proccss stages, a scquence of processes or process stages, er the like.
Many of these measurable characteristics have a range of possiblc values, which nnay or may not change, or vary, over time. It is desirable, in the present example, to determine an efficient prediction form ("EPF"), the range of values of which may suitably be maintained in lookup table 165.
Proeessor 205 ir, direetact to populate ones of the accessiblc fields 255 of lookup table 165 with a range of possible values of at least one measureble characteristxc associated with at least process 110 (process step 260). An oxemplary source code embodiment for performing this population is attached as ApPENnIx B, and that is written in Pascal. According to the illustrative embodiment, it is dcsirable to have future predictions available, or precalculated, which may suitably be stored as an array of points within lookup table 165. This coliection of points may be referred to as PV-blockir,g, which may be given by the following form for any pi interval, or pofint in the futare:

y(k+p1jk n A Y(k+pv-b1ocking)jk m y` +r~Ik m Y(k+pmlk wl>ezein f is the index for PV-blocking. The foregoia,g caleulation may suitably be c:oadensed into a product of FPF and Zk, which may be given by:

n .Y(k+pv-blocking)!k = [EPF1zk) wherein EPF inay be given by;
epfl epf2 [EPF] _ (9) epf m wherein opf, is independent fiozn. the feed back information contained in the Z vector and may theaeforc be calculated in advance and given by:

A B pi epf = [CD] 0 I (10) In short, exemplary processor 205 uses model 220 iteratively, or incrementally, to populate lookup table 165 with k possible values, thereby defining a range of values.
A Vk vector is formulated to conveniently calculate both Zk and y(k+pvblocking)jk for different incremental k, which has the following form:

AB zk A
V k+1 - EPB, zk V k y(k+ pvb1 o ck i n g) k(11) Turning momentarily to FIGURE 3, illustrated is an exemplary two-dimensional graphical representation of MV and PV curves in accordance with a use of lookup table 165 in accordance with the control system 100 of FIGURES la and lb and the principles of the present invention. It should be noted, that FIGURES l a, 1 b, 2, and 3, along with the various embodiments used to describe the principles of the present invention in this patent document are illustrative only. To that end, alternate embodiments of model 220 may define any particular process, a group of processes, a facility, a process stage, a group of process stages, an interrelationship among, or a sequence of, processes or process stages, or some suitable portion or combination of any of the same. It should be further noted that a matrix structure was chosen for the EPF in this embodiment, however, alternate embodiments may use any appropriate data structure or dedicated circuitry to create a suitably arranged lookup array, or table, or the like. Such data structures and dedicated circuitry may be populated off-line, on-line or through some suitable combination of the same; likewise, such populated data structures and dedicated circuitry may be static, dynamic, modifiable, centralized, distributed, or any suitable combination of the same.

Those of ordinary skill in the art should recognize that the computer system described using processor 205 and memory 210 may be any suitably arranged hand-held, laptop/notebook, mini, mainframe or super computer, as well as network combination of the same. In point of fact, alternate embodiments of computer system 205 may include, or be replaced by, or combined with, any suitable circuitry, including programmable logic devices, such as programmable array logic ("PALs") and programmable logic arrays ("PLAs"), digital signal processors ("DSPs"), field prograrrunable gate arrays ( `FPGAs"), application specific integrated circuiu ("ASYCs"), very large scale integratcd circuits ("VLSIs") or the like, to form the procossing systems described and claimed herein. To that end, while the disclosed embodiments require processor 205 to access and to execute a stored task/instsnctions from memory to perform the vanous functions described hereabovc, alternate embodiments may cerminly be implementcd cntirely or partially in hardware.
Conventional processing system architecture is more fulay discussed in m ter Organization antl_Architecture, by William Stallings, MacMillan Publishing Co.
(3rd ed.
1993); conventional processing system network design is more fully discussed in Data Network Desien, by Darrcn L. Spohn, McGraw-plill, Inc. (1993); and conventional data comrnmaications is more fully discussed in Data Cemmunications Princinles by R. D.
Gitlin, J. F. Hayes and S, B. Weinstein, Plenum Press (1992) and in The Irwin Handboo c of Telecornmunicati ons, by James Harry Qrecn, Irwin Profcssional PubUshing (2nd ed. 1992).

APPrNnY~A_ { System name: SPID }
{ BEGIN IHDR }
{ FILE: /Jnk/spid/prv/src/sp_data.i.s }
{ VER/REV: 01,01 }
{ DATE: 05/14/98 }
{ HonoyweIl Trade Secret - Treat as Honeywell PROPRIE7.'ARY }
{ END IIDR }
{(~:PCHr:}
unit 5P DATA;
intetface uses mc data, iuv_data;
(:PCHP,i)}
CONST
SPM VERSION = 100_0000; {currcnt version) max_n_blk = 10;
max_n_den = 5;
max_num_pin = 6;
max delay_def = 200;
URV_tol = 0.001;
ON =1;
OFF = 0;
WARM = 11;
FORCE = 1;
AUTO = 0;

D_GRT_THAN_MAXD = 201;
BAD NUM_OR DEN = 202;
BAD_DEN_INTEGRATOR = 203;
NEGATIVE DEN_COEF = 204;
ZERO_GAIN = 205;
ALLOC_S_Z_ERR = 206;
BAD_MAXD_INT = 207;
BAD_T_CON = 208;
TYPE

sp_block_arr = array [l..max_n_blk] of single;
sp_block_arr_ptr = ^sp_blockarr;
coef arr = array [l..max_n den] of single; { Predictor model F-polynom.
coefficients }
coef arr_ptr = ^coef arr;

coef arrs = array [ 1..max_n den * max_num_pin] of single; { Predictor model F-polynom. coefficients }

sp_pin_arr_i = array [l..max num_pin] of integer;
sp_pin_arr_s = array [l..max num_pin] of single;
sp_pool_data_ptr = ^sp_pool_data;
sp_cds_data_ptr = ^sp_cds_data;
sp_cds_data = record { --------------------------------------------------------------------------- Section 1: Model Data Input Seciton (must have init value/BLD_visible) ------------------------------------------------------------------------- }

{continuous model { spid_cds:CAL }

n dv : single; { No. of DVs }
{used as integer}
{spid_cds:CALC1(1..6)}
n_num : sp_pin_arr_s; { No. of B-poly coefficients }
{used as integer}
{ spid_cds: CALC2( l ..6) }

n_den : sp_pin_arr s; { No. of F-poly coefficients }
{used asinteger}
{spid_cds:CONV 1(1..30)}

num : coef arrs; { Predictor model B-polynom. coefficients }
{ spid_cds: CONV2(1..3 0) }

den : coef arrs; { Predictor model F-polynom. coefficients }
{spid_cds:CD(1..6)}
delay sp_pin_arr_s; { Dead-time (continuous) }
{used as integer}
{spid_cds:CC(1..6)}

G_s : sp_pin_arr_s; { Steady-state gains, used by controller }

{ spid_cds: CMD( l ..6) }

max_delay : sp_pin_arr_s; { Max dead-time (continuous) }
{used asinteger}
{spid_cds:CPROF}
perf rat : single; { Performance ratio - feedback }
{spid_cds:CTREND3 }

Three_Tau : single; { Three Tau (continuous) } {used as integer}

{discrete model}
{ spid_cds:DEF 1(1..6) }
n b : sp_pin_arr_s; {# of num coef (discrete) } {used as integer}
{ spid_cds:DEF2(1..6) }

n f : sp_pin_arr_s; {# of dnum coef (discrete) } {used as integer}
{spid_cds:DEMNDINl (1..30)}

b_z coef arrs; { num coefs (discrete) }

{ spid_cds:DEMNDIN2(1..30) }

f z : coef arrs; { dnum coefs (discrete) }

{ spid_cds:DDD( l ..6) }
d : sp_pin_arr_s; { Dead-time (intervals) }
{used as integer}
{ spid_cds:DDFPNT(1..6) }
max d int : sp_pin_arr_s; { maxd / T_con; (intervals) }
{used as integer}
{spid_cds:TSLOAD}
T_con : single; { Control execution interval (minutes) }
{ spid_cds:NUMSTIL }

{ --------------------------------------------------------------------------- Section 2: Variables used by Pascal/CL/LCN GUI

-------------------------------------------------------------------------}
{ spid_cds: YY_L }
y_L_ent : single; {Entered CV low limit. }

{ spid_cds: YY_H }

y_H_ent : single; {Entered CV high limit. }
{spid_cds:Y_L}
y_L : single; { CV low limit }
{ spid_cds: Y_H }

y_H : single; { CV high limit }
{ spid_cds: YY}

y : single; { Current source value }

{spid_cds:Y NOTOK}

y_not_ok : single; { 1: -> y value is uncertain/out of range }

{spid_cds:YVAL1 }
first_on : single; { first time after pv service }

{spid_cds:YSEL}
y_hat : single;
{spid_cds:Yl }

y_last : single; { Last good y value }
{ spid_cds: YVAL2 }

y_Filt_Bias : single; { Filtered y-bias for bias updating,Pool? }
{spid_cds:YVAL3 }
Filt Const : single; {Bias correction Filter Factore, Pool? }

{spid_cds:YLDNEW}
y_Filt_Ramp : single;
{ spid_cds: YLDTGT}
y_Filt_Ramp2 : single;
{ spid_cds: YIELD }
Filt_opt_Const : single ;

{ spid_cds:YIELDINT}
Filt opt_Const2: single ;
{spid_cds:Y2}
y_last_BAD : single; { 1=> Last y is BAD, 0=> Good,P }
{spid_cds:TYPE}
y_type : single; { 0: stable, l:integrator, LCN GUI uses it }
{ spid_cds:Y_PRI }
y_UFPO : single;
{spid_cds:Y NEWVAL(1..21)}
y_UFP : array [0..20] of single; { Unforced prediction}
{spid_cds:UNDIV01 }
u L_ent : single; {Entered MV low limit. }
{ spid_cds:UNDIV02 }
u H_ent : single; {Entered MV high limit. }
{spid_cds:U_L}

u L : single; { MV low limit }

{spid_cds:U_H}
u H : single; { MV high limit }
{spid_cds:LOWLIM}
du L : single; { MV move low limit }

{ spid_cds:HIGHLIM }
du H : single; { MV move high limit }

{ spid_cds: UCL(1..6) }
u : sp_pin_arr_s; { Current actual value }

{ spid_cds:U 1(1..6) }
uml : sp_pin_arr_s; { MV at previous interval }

{spid_cds:U_0}
u 0 : single; { Output from controller }

{spid_cds:DIS NAME}

ss_display : single; { PC use only. use in simulation. Flag: 0 means display ss values }
{spid_cds:STP}

saved 3t_pr : single; { saved Three_Tau ( for integrator ) or Perf rat ( for stable ) }
{spid_cds:FLAGS }

setup_flag : single; { if = force, call setup; if = auto, don't call setup except necessory }

n sJL : single; { No. of intervals for J.L.'s mods} {used as integer}

{spid_cds:BLOLVL( l ..10)}
y_blk : sp_block_arr; { CV blocking values }

{spid_cds:BLOMNMIN}
y_num_blk : single; { total # of blocking intervals }

{spid_cds:BLOTIPC}

y_num_start : single; { starting # of actual blocking intervals }

{spid_cds:BLOMIN}
y_num_end : single; { actual # of blocking intervals }

{ spid_cds: DIFPRXX(1.. 5 ) }

dx : coef arr; { used in spidScalc}
{ spid_cds:ZOOMDEV (1..5) }

z : coef arr; { used in spidScalc}

{ spid_cds:NUMSAMP }
n mvblk : single; { mv block sampling time } {used as integer}
{ spid_cds:BLRQ(1..10) }

mv_blk sp_block_arr; { used in spidScalc}
{rmpc_cds:MODFACT}
controller mode : single; {only on DLL for now, 0-off; l -on;ll -warm}
{ spid_cds: V VP }

version : single; { save the release version in cds}
{spid_cds:INITPASS}
initpass : single; { Initialization pass counter }

{spid_cds:COUNTER}

predi_counter : single; {useful in debugging, the same as kt}
{ spid_cds:D l }

now alarm : single; { Current alarm indicators }

{ spid_cds: QANAPNT(1..10) }
QMapcds : sp_block_arr;
{spid_cds:ENTMPO11(1..150)}
epflcds : array [l..max n den *
max_n_den * max_num_pin] of single;
{ spid_cds:ENTMPO 12(1..300) }
epf2cds : array [l..max_n blk * max_n_den * max num_pin] of single;

{ spid_cds : DY(1.. 51) }
dys : array [0..max_delay_def] of single; { Output from controller }
{spid_cds:CDPNT}
myloc sp_cds_data_ptr; { Initialization pass counter}

{ spid_cds: SPARE(1..3 0) }
spares : array [1..30] of single;
{ --------------------------------------------------------------------------- Section 3: CL/LCN GUI Only ------------------------------------------------------------------------- }
{spid_cds:TIMERQST}
time_diff : single; { The amount of CPU time in milliseconds }

end;
{KYS - save the whole QMap or QMapl which is the lst row of QMap ?}
sp_pool_data = record y_end : sp_block_arr_ptr;
n_s : integer;
s_z : heap_array_s_ptr;
epfl : Matrix_Type;
epf2 : Matrix_Type;
QMap : Matrix_Type;
end;

{(*:PCHP:}
implementation end.
{:PCHP:*)}
{ end sp_data }

APPENDIX B
{ System name: SPID }
{BEGIN HDR }
{ LCN FILE: /lnk/rmpc/prv/src/sp_proc.s }
{ PC FILE: sp_proc.pas }
{ DATE: 05/20/98 }
{ Honeywell Trade Secret - Treat as Honeywell PROPRIETARY }
{ END HDR }

{(*:PCHP:}
unit SP_PROC;

{$N+,E- 8087 IEEE floating-point, no emulation}
{$A+,B-,G+ Word align, Boolean shortcut, protected mode}
interface uses sp_data, mc_data {:PC_USE:}, urv_data {:}, mc_lib, mc_rca, mem_mnag;
procedure sp_ctfcheck(model_no : integer;

n_dv : integer;
var n_num : single;
var n_den : single;
var num : coef arrs;
var den : coef arrs;
var G_s : single;
delay : single;
var max_delay : sp_pin_arr_s;
var max_d_int : sp_pin arr s;
T_con : single;
var setup_flag : single;
Three_Tau : single;
perf rat : single;
y_type : single;
var saved_3t_pr : single;

var call_setup : single;
var status : single);
procedure get_3tau (n_den : integer;
var den : coef arrs;
var Three_Tau : single;
var status : single);
procedure sp_blocker ({ Inputs -- }
delay_int : single;
{ Dead-times. }
n_sJL : single;
{ Number of intervals for J.L.'s mods. }
perf rat : single;
{ FF cntl/FB cntl response ratio.}
{ Outputs -- }
var y_blk : sp_block_arr;
{ CV block intervals (1 is current).}
var y_num_blk : single;
{ No. of block intervals per CV.}
var Rtc : single;
{ the beginning of control horizon}
var status: single { Status of blocker calcs});
Procedure spid_calc_S_z (n_B : single;

var B_z : coef arrs;
n_F : single;
var F z : coef arrs;
kp : integer;
var S_z : heap_array_s_ptr;
var status : single);

procedure sp_ctrans (model_no : integer;

n_num : single;
n_den : single;
var num coef arrs;
var den coef arrs;
G_s single;
T_con : single;
{output}
var n_b : single;
var n_f single;
var b_z coef arrs;
var f z : coefarrs;
var status : single);

procedure sp_dtf2epfp (n_b : single;
n_f : single;
var b_z : coef arrs;
var f z : coef arrs;
y_num_end integer;
var y_end : sp_block_arr;
delay_int : single;
lcnunit : integer;
n_order : integer;
{output}
var epfl Matrix_Type;
var epf2 : Matrix_Type;
var status : single);
procedure new alloc_urv (var urv : urv_set;

tot num_cv, {will include num of combined constraints for DQP}

num_mv : integer;
callerlD integer; {see URV_DATA.PAS
for definition}
lcnunit {:LCN_USE: : $unit identifier; :}

{:HP_USE: : integer; :}
{:VAX_USE: : integer; :}
{:GHS_USE: : integer; :}
{:PC_USE:} : integer; {:}{Point's unit } var status single);
(*:LOCAL:*) procedure new release_urv(var urv : urv_set;

lcnunit {:LCN_USE:
$unit_identifier; : }

{:HP_USE: : integer; :}
{ : VAX_USE: : integer; : }

{:GHS_USE: : integer; :}

{:PC_USE:} : integer; {:}{ Point's unit }
var status : single);
(*:LOCAL:*) procedure sp_h2solut (n_s : integer;
var n mvblk : single;
var mv blk : sp_block_arr;
var s_z : heap_array_s_ptr;
y_num_end : integer;
var y_end : sp_block_arr; { CV block intervals (1 is current). }

delay_int : single;
y_type : single;
G_s : single;
n_sJL : single;
lcnunit : integer;
override_tol: single;

var QMap : Matrix_Type;
var status : single implementation {:PCHP:*)}
{&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&}
procedure sp_ctfcheck( model no : integer;
n_dv : integer;
var n_num : single;
var n_den : single;
var num : coef arrs;
var den : coef arrs;
var G_s single;
delay single;
var max_delay : sp_pin_arr_s;
var max_d_int sp_pin_arr s;
T_con : single;
var setup_flag : single;
Three_Tau : single;
perf rat : single;
y_type : single;
var saved_3t_pr : single;
var call_setup : single;
var status : single);
var i, j, total_max d_int, first non_zero_ind: integer;
begin if status = 0 then begin { status = 01 { if (call_setup = force) or the condition below is satisfied, call setup }

if ( call_setup = AUTO ) and ( ( setup_flag = FORCE ) or ( (y_type = 0) and (perf rat o saved_3t_pr) ) or ( (y_type = 1) and (Three_Tau <>
saved_3t_pr) ) ) then call_setup := FORCE;
if call_setup=FORCE then begin {call_setup}

while (n_den > 0 ) and ( den[round(n_den)] = 0) do n_den := n_den - 1;

while (n_num > 0) and ( num[round(n_num)] = 0 ) do n_num := n_num - 1;

if (delay > max_delay[model_no]) then status := D GRT THAN MAXD
else if T con <= 0 then status := BAD T CON

else if (n_num > max_n den) or (n_den >
max_n_den) or (n_num >= n_den) or (n_num < 1) or (n_den < 2) then status := BAD NUM-OR DEN;

if status = 0 then begin {n_num and n den are inside of ranges}

first non-zero-ind := 1;
while ( first_non zero-ind <=
n_den ) and ( den[first non-zero_ind] = 0 do first non zero ind =
first non zero-ind + 1;

max_d-int[model-no]
round(max delay[model-no] / T con);

total-max-d-int := 0;
for j:= 1 to (n_dv+l) do total max d int =
total max d int +

round(max-d-i nt[j]);

if ( total-max d-int >
max_delay_def ) then status =
BAD_MAXD-INT

else if ( first-non-zero-ind > n - den ) or ( first-non-zero-ind > 3 ) then status =
BAD DEN INTEGRATOR

else begin for j =
(first non_zero_ind+l ) to round(n_den) do den[j] den[j] /
den[first non zero_ind];

Gs .= Gs *
den[first_non zero_ind];

den[first non zero_ind] := 1;

for i .= 2 to round(n_den) do if den[i] < 0 then status NEGATIVE_DEN_COEF;

end;
if status = 0 then if num [ 1]= 0 then status =
ZERO_GAIN

else begin for j := 2 to round(n_num) do num[j] := num[j] / num[1];

G-s:=G - s/
~ ..
num[1];

num[l] := 1;
end;

end; {n_num and n den are inside of ranges}

end; { call_setup }
end; { status = 0 }
end;

{&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&}
procedure get_3tau ( n_den integer;

var den : coef arrs;

var Three_Tau : single;

var status : single);

var i integer;
mt : single;
begin if status = 0.0 then begin {status = 0.0}

Three_Tau := 0;
for i:= 1 to n den-1 do begin {for}
if i = 1 then mt := den[2]
else if i = 2 then mt := sqrt(den[3]) else if i = 3 then mt:=exp(ln(den[4])/3) else mt := sqrt( sqrt( den[5] ) );

if mt > Three Tau then Three_Tau := mt;
end; {for}

Three_Tau := Three_Tau * 3;

end; {status = 0.01 end;

{&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&}
Procedure spid_calc_S_z( n B: single;

var B_z : coef arrs;
n_F : single;
var F_z : coef arrs;
kp : integer;
var S_z : heap_array_s_ptr;
var status : single ); (*:LOCAL:*) Var loc_y : array[-n_F_max_dim..0] of single;
total_B, term i, term2 : single;

i, i_kp : integer;

Begin {spid_calc_S_z}
if status = 0.0 then begin {status = 0}
{Calc total_B to save calculations later.}
total_B := 0.0;
for i:= 1 to round(n_B) do total_B := total_B + B_z[i];

{Initialize loc_y array to 0}
for i := 0 to round(n_F) do loc_y[-i] := 0.0;

for i_kp := 1 to kp do begin {i_kp}

{First, shift ("age") loc_y array}
for i- round(n_F) to -1 do loc_y[i] :=1oc y[i+l];

{Then, find terml - the contribution of B_z}
if i_kp > round(n_B) then term 1 := total B
else begin terml := B_z[1];
for i := 2 to ikpdo terml := terml + B_z[i];
end;

{Next, calculate term2 - the contribution of F_z}
term2 := 0.0;
for i:= 1 to round(n_F) do term2 := term2 - F_z[i] * loc_y[-i];

{Finally, put current y into loc_y[0]}
loc_y[0] := terml + term2;
s_z^[i_kp] := loc_y[0];
end; { i_kp }
end; {status = 01 End; {spidcalcSz}

{&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&}
procedure sp_blocker { Inputs -- }

delay_int : single ; { Dead-times.
}

n_sJL : single ; { Number of intervals for J.L.'s mods. }

perf rat : single ; { FF cntl/FB cntl response ratio. }
{ Outputs -- }
var y_blk : sp_block_arr ;{ CV block intervals (1 is current). }
var y_num_blk : single ;{ No. of block intervals per CV .
}

var Rtc : single ;{ the beginning of control horizon }
var status: single { Status of blocker calcs }

var Rte, Rti : single;

i, nkvi : integer;
Iv temp : cv block arr;

Kv_temp : cv_block_arr;
begin { Start blocking calculations }
if status = 0.0 then begin {status = 0}
{for SISO, Rti = Resp_time = n sJL }
Rti := n_sJL + delay_int;
Rtc := minr(1, perf rat) * n_SJL + delay_int;
Rte:=(Rti+Rtc)/2;
GetPVblk( Kv_temp, Iv_temp, nkvi, round(delay_int), Rtc, Rte, 10, 1, 1, false, 1.0);
for i 1 to nkvi do y_blk[i] := Kv_temp[i];
y_num_blk := nkvi;
end; { status = 01 end; { End blocking calculations }

{&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&}
procedure sp_ctrans (model no : integer;
n num single;

n den single;
var num coef arrs;
var den coef arrs;

G_s single;
T_con : single;
{output}

var nb single;

var n_f : single;
var b_z : coef arrs;
var f z : coef arrs;
var status : single);
var n_numi, n_deni : integer;
sqtau2, taulmul4, tmidl, tmid2, tmid3, tmid4, tmid5, tmid6, tmid7, tmid8, a, b single;

numptr, denptr, b_z_ptr, f z_ptr : coef arr_ptr;
begin { ctrans }
if status = 0.0 then begin {status = 0}
n_numi := round(n_num);
n deni := round(n_den);

if (n_numi = 1) and (n_deni = 2) and (den[1] = 0) then begin { 1/S }
n_b .= 1;
n_f .= 1;
b_z[1] G_s * T_con;
f z[1] :=-l;

end { 1 /S }

else if (n_numi = 1) and (n_deni = 2) and (den[1 ]= 1) then begin { 1/( tl * S+ 1)}
n b.=1;
nf.=1;
b_z[1] := G_s * (1 - exp( -T_con / den[2]));
f z[1] - exp(-T_con / den[2]);
end {1/(tl*S+1)}

else if (n_numi = 1) and (n_deni = 3) and (den[1] = 1) then begin { 1/( tl * S^2 + t2 * S+ 1) }
n b:=2;
n f:=2;
sqtau2 := sqr ( den[2] );
taulmul4 := den[3] * 4;
tmidl := sqrt(abs( sqtau2 - taulmul4 ));
if ( tmid 1< eps ) then begin tmid2 := T_con / sqrt(den[3]);
tmid3 := exp (-tmid2);
b_z[1]:=G_s*(1-tmid3*(1+
tmid2) );

b_z[2] := G_s * tmid3 * (tmid3 +
tmid2 - 1);

f z[1] (-2) * tmid3;
f z[2] := tmid3 * tmid3;
end {kys - think about sqtau2 = taulmul4}
else if ( sqtau2 < taulmul4 ) then begin { Tau2^2 less then ( 4 * Taul ), wO
}

tmid8 := den[3] * 2;

tmid2 := tmidl / tmid8;
tmid7 := tmid2 * T_con;
tmid5 cos(tmid7);
tmid6 sin(tmid7);
tmid3 := den[2] / tmidl * tmid6;
tmid4 exp ( - den[2] / tmid8 *
T_con);

b_z[1] := G_s * ( 1 - tmid4 * ( tmid5 + tmid3 ) );

b_z[2] G_s *( sqr(tmid4) +
tmid4 * ( tmid3 - tmid5) );

f z[l] -2 * tmid4 * tmid5;
f z[2] := sqr( tmid4 );
end { Tau2^2 less then ( 4 *
Taul ), wO
}

else if ( sqtau2 > taulmul4 ) then begin { Tau2^2 greater then ( 4 *
Taul ), ab }

a(den[2] - tmidl) * 0.5 / den[3];
b (den[2] + tmidl) * 0.5 / den[3];
tmid2 := tmidl / den[3]; {b-a}
tmid3 :=exp(-a* T con);
tmid4 :=exp(-b * T_con);
b_z[1] := G s * (b * (1-tmid3) - a *
(1-tmid4)) / tmid2;

b_z[2] G_s * (a * (1-tmid4) *
tmid3 - b * (1-tmid3) * tmid4) / tmid2;

f z[1] :_ - tmid3 - tmid4;
f z[2] exp (- den[2] / den[3] *
T_con );

end; { Tau2^2 greater then ( 4 Taul ), ab }

end { 1/( t l* S^2 + t2 * S + 1) }

else begin {(*:PC_ONLY: }
writeln('Ctrans cannot do it now');
{ :PC_ONLY: * ) }
{status := 100; }
end;

end; {status = 0}
end; { ctrans }

{&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&}
{[epfl, epf2]=dtf2epfp(mn,md,pv_end-mdt,0) }
procedure sp_dtf2epfp ( nb single;

nf single;

var b_z : coef arrs;

var f z : coef arrs;

y_num_end : integer;
~
var y_end : sp_block_arr;

delay_int : single;

lcnunit : integer;

n_order integer;
{output}

var epfl Matrix_Type;
var epf2 : Matrix_Type;

var status : single);

var pvrow Row;
n 1, get_amount, i, j, i 1, j 1 : integer;
code : single;
gen_ptr : r_anyptr;
begin { sp_dtf2epfp }
if status = 0.0 then begin {status = 01 code := 0.0;

for i:= 1 to n order do begin epfl.mat[i]^[1] :=-f z[i];
for j 2 to n order do if (j=i+1) then epfl.mat[i]^[j] := 1 else epfl.mat[i]^[j] .= 0;
end;

if status = 0.0 then begin {no error after sp_tf2obsv}
for i 1 to n order do epfl.mat[i]^[epfl.m] := b_z[i];
for j:= 1 to n_order do epfl.mat[epfl.n]^(j] := 0.0;

epfl.mat[epfl.n]^[epfl.m] := 1;
for j 1 to epfl.n do pvrow(j] := epfl.mat[1]^[j];
i = 1;
for j := 1 to round(y_end[y_num_end]-delay_int) do begin PreVectMult (pvrow, epfl, epf2.mat[i]^);
for j 1:= 1 to epfl.m do pvrow[j 1 ] _ epf2.mat[i]^[j 1 ];

if ( j = round(y_end[i]-delay_int) ) then .=i+1;
end;

epfl.n := epfl.n -1; {taking out the last row, but leaving the memory}

end; {no error after sp_tf2obsv}
end; { status = 0}
end; { sp_dtf2epfpcal }

{&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&}
{ ----------------------------------------------------------------------------------------- }
{Procedure to allocate space for U, R, and V. Called from setup }
{and from rca body (in order to get second URV for PreRCA) }
{ ----------------------------------------------------------------------------------------- }
procedure new alloc_urv ( var urv : urv_set;

tot num_cv, {will include num of combined constraints for DQP}
num_mv : integer;

callerlD : integer; {see URV_DATA.PAS for definition}
lcnunit {:LCN_USE: : $unit_identifier; :}

{:HP_USE: : integer; :}
{:VAX_USE: : integer; :}
{:GHS_USE: : integer; :}

{:PC_USE:} : integer; {:}{ Point's unit }
var status : single); (*:LOCAL:*) var n,m,i : integer;
code : single;
begin {new_alloc_urv}

code := 0.0;
with urv do begin {with urv}
{Based on callerlD, calculate n and m.}
if (callerlD = CID_RMPCT) or (callerlD =
CID_RMPCT PRERCA) then begin {later, might determine different (smaller) size for PreRCA}
n:= maxi(tot_num_cv * max_cv blk + num_mv *
(max_mv_blk-1), tot num_cv * 2 + num_mv + 1);

{for dynamic CV
rows} {for dynamic CX rows} {for SS CV row + extra LP/QProws}
m := num_mv * max_mv blk;
end else if (callerID = CID DQP) then begin n:= tot num_cv * 2 + num_mv + 1;
{for SS CV row + extra LP/QProws}

m := num mv;
end else if (callerlD = CID_SPID) then begin n := tot num cv;
m num mv;
end else begin n := 0;
m .= 0;
end;

n := mini(max row size, n);

{double check MC Control/OptSS later, what if n >
max_row_size??? }

{store size allocated for later use in release urv}
n_alloc := n;
m_alloc := m;
{grab space for U}
for i := 1 to n do U.mat[i] := (*:loophole:*) Row_ptr ( new mc_getmem(n * sizeof(URV_sd), lcnunit, code, status));
{grab space for R}
for i:= 1 to n do R.mat[i] := (*:loophole:*) Row_ptr ( new_mc_getmem(m * sizeof(URV_sd), lcnunit, code, status));
{grab space for V}
for i:= 1 to m do V.mat[i] := (*:loophole:*) Row_ptr ( new mc_getmem(m * sizeof(URV_sd), lcnunit, code, status));
U.n:=O; U.m:=O;
R.n:=O; R.m:=O;
V.n:=O; V.m:=O;
R.mt := UpperTri;
end; {with urv}
end; {new_alloc_urv}
{&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&}
procedure new release_urv(var urv : urv_set;

lcnunit {:LCN_USE: : $unit identifier;
:}

{:HP_USE: : integer; :}
{:VAX_USE: : integer; :}

{:GHS_USE: : integer; :}

{:PC_USE:} : integer; {:}{ Point's unit }
var status : single); (*:LOCAL:*) var n,m,i, get_amount : integer;
gen_ptr : r_anyptr;

begin {new release urv}
with urv do begin {with urv}
n := n_alloc;
m := m_alloc;
{grab space for U}
get_amount := n * sizeof(URV_sd);
for i:= 1 to n do begin gen_ptr := (* :loophole: *)r_anyptr(U.mat[i]);
new mc_freemem(gen_ptr, get_amount, lcnunit, status);

end;
{grab space for R}
get_amount := m * sizeof(URV_sd);
for i := 1 to n do begin gen_ptr := (*:loophole:*)r_anyptr(R.mat[i]);
new mc_freemem(gen_ptr, get_amount, lcnunit, status);
end;
{ grab space for V }
get_amount := m * sizeof(URV_sd);
for i := 1 to m do begin gen_ptr := (*:loophole:*)r_anyptr(V.mat[i]);
new mc_freemem(gen_ptr, get_amount, lcnunit, status);

end;

end; {with urv}
end; {new release_urv}

{&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&}
procedure getmvblk ( var nblk : integer;

lastblk : integer;

dense : integer;

var mv blk : sp_block_arr var i integer;
begin {getmvblk}

if nblk >= max n blk then nblk := max n blk;
if (lastblk <= nblk) then begin { lastblk <= nblk }
for i:= 1 to lastblk do mv_blk[i] := i;
nblk lastblk;
end { lastblk <= nblk }
else begin { lastblk > nblk }
mv_blk[1] := 1;
for i 2 to nblk do mv_blk[i] := 0;
for i:= 2 to nblk do begin mv_blk[i] mv_blk[i] + ( exp (dense * i / nblk) -1)*

( lastblk / ( exp(dense) - 1 ) );
if mv_blk[i] > (mv_blk[i-1] + 1) then mv blk[i] := round( mv_blk[i] ) else begin if i < nblk then mv_blk[i + 1] := mv_blk[i +
1] +

( mv_blk[i - 1] + 1 -mv_blk[i] ) / 2;
mv_blk[i] := mv_blk[i - 1] + 1;
end;

end;
end; { lastblk > nblk }
end; {getmvblk}

{&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&}
procedure sp_h2solut ( n_s : integer;
var n mvblk : single;
var mv blk : sp_block_arr;
var s_z : heap_array_s_ptr;
y_num_end : integer;
var y_end : sp_block_arr; { CV block intervals (1 is current). }

delay_int : single;
y_type : single;
G_s : single;
n_sJL : single;
lcnunit : integer;
override_tol: single;
var QMap : Matrix_Type;
var status : single );
var return single;

i, j, dense, n mvblki, last blk : integer;
urv urv set;
built row Row;

------- -{ A }
{Finds a value in the A matrix, which is never explicitly built as a }
{complete matrix. The only parameters to A are i and j, the row and }
{column indices in A. A does, however, access several of the parameters }

{that are passed to the main RCA procedure that calls A. These "global"
}

{parameters are }
{ }
{ pv_blk, -- single array, index is row or column in our A, }

{ value is index to entire matrix "S?" of step }
{ response data }
{ }
{ delay_int -- integer, value is dead time for each block }
{ }
{ S_z -- array of step response polynomials}
{ n_S -- integer, value is number of values in }

{ step response polynomial }

Function A(i,j : integer) : single; (*:LOCAL:*) var value : URV_sd;
ind S: integer; {index within step response polynomial}
Begin {A}

value := 0.0;

{use the 5 tau value if process is unstable}
{Q2J - verify}
ind S:= round(y_end[i] - delay_int - j + 1);
if ind S> 0 then begin if ind S<= n S then value := S_z^[ind_S]
else if ( y_type = 1) then {not stable}
value := S_z^[n_S] + G_s * (ind_S - n_S) else value := S_z^[n_S];
end;

{
if ( (i j+l) > 0 ) then value := S_z^[i j+l];
}
A := value;
End; {A}

{ -----------------------------------------------------------------------------}
{start of sp_h2solut procedure body}
{---------------------------------------------------------------------------------}
begin {sp_h2solut}
if status = 0.0 then begin {status = 0}
dense := 3;
n mvblki := round(n_mvblk);
last blk := round( minr(n_sJL, y_end[ynum_end] - delay_int) );
getmvblk (n_mvblki, last blk, dense, mv_blk);
new alloc_urv ( urv, y_num_end, n_mvblki, CID_SPID, lcnunit, status);

if status = 0.0 then with urv do begin {with urv}
return := successful;
k .= 0;

{QMap = pinv(Hss) = V * (R \ U') }
{URVAddRow returns U, R, and V, no transpose }

for i:= 1 to y_num_end do begin for j:= 1 to n mvblki do built_row[j] := A(i, round(mv_blk[j]) );

{ built_row[j]
A_blk(i,j); }

return =
URVAddRow(U,R,V,k, built row, n mvblki);

end;

for i:= 1 to R.n do begin for j:= 1 to k do built_row[j]
U.mat[i]^[j];

{R\U', pass U' collom which is U row into built row, built row is a used as collom}
return := ForwardBackSub (R, built_row, k);

{ PostVectMult (V, built_row, QMap.mat[i]^);

QMap is acturally QMap's transpose here We do not need to calculate the whole QMap on Am, but for offline, probably.
}

QMap.mat[1]^[i] := 0;
for j:= 1 to k do QMap.mat[1]^[i]
QMap.mat[1]^[i] +

V.mat[1]^[j] * built_row[j];
{ QMap.mat[ 1 ]^[i]
QMap.mat[1]^[i] / ( n_s/n_mvblk ); }
end;
new-release_urv(urv, lcnunit, status);
end; {with urv}
n mvblk := n mvblki;
end; { status = 0.0 1 end; {sp_h2solut}

{(*:PCHP:}
END. {of unit}
{:PCHP:*)}

Claims (10)

1. A computer system for use with a process facility (100) having a plurality of associated processes, comprising:
circuitry (210) that is capable of maintaining a data structure having a plurality of accessible fields; and a processor (203), associated with said circuitry, that is capable of populating ones of said plurality of accessible fields of said data structure with a range of possible values of at least one measurable characteristic associated with at least one process of said plurality of associated processes:
wherein said circuitry is capable of maintaining a model of at least a portion of said plurality of associated processes and characterised in that;
wherein said model comprises a discrete state space model of the form:
X k+1 = AX k + BU k and Y k = CX k + DU k where X k and U k and Y k represent states of a modeled process and where k is a time period and k + 1 is a next time period and where A, B, C, and D
respectively represent measurable characteristics of said modeled process at any given time period.

2. The computer system set forth in claim 1, wherein said circuitry (210) is arranged to store a task that directs said processor (205) to populate said ones of said plurality of accessible fields of said data structure with said range of possible values.

3. The computer system set forth in claim 1, wherein said circuitry (210) is further capable of maintaining said model where said model comprises a data structure of at least a portion of said plurality of associated processes wherein said data structure comprises an ABOI matrix of the form:

where A and B represent measurable characteristics of a modeled process and where I is an identity matrix and O is a null matrix and wherein data structure comprises a feedback vector of the form:

where X k and U k represent states of said modeled process and where K is a time period.

4. The computer system set fourth in claim 3, wherein said model includes a mathematical representation of at least a portion of said at least one process of said plurality of associated processes, said mathematical representation defining relationships among inputs and outputs of said at least one process of said associated processes wherein said mathematical relationship is of the form:

where Z k represents a state space vector of the form:

5. The computer system set forth in claim 4, wherein said processor (205) is capable of using said model iteratively to populate ones of said plurality of accessible fields of said data structure with said range of possible values of said at least one measurable characteristic, wherein said model gives a prediction form for any point p in the future and wherein said prediction is of the form:

6. A method of operating a computer system that is for use with a process facility (100) having a plurality of associated processes, said method of operation comprising the steps of:

maintaining a data structure having a plurality of accessible fields in circuitry (210) associated with said computer system;
populating ones of said plurality of accessible fields of said data structure using a processor (205), that is associated with said circuitry, with a range of possible values of at least one process of said plurality of associated processes; and maintaining a model in said circuitry of at least a portion of said plurality of associated processes, characterised in that said model comprises a discrete state space model of the form:
X k+1=AX k + BU k and Y k = CX k + DU k where X k and U k and V k represent states of a modeled process and where k is a time period and k + 1 is a next time period and where A, B, C and D respectively represent measurable characteristics of said modeled process at any given time period.

7. The method of operation set forth in claim 6, further including the step of storing a task in said circuitry (210) that is capable of directing said processor (205) to populate said ones of said plurality of accessible fields of said data structure with said range of possible values.

8. The method of operation set forth in claim 6, further comprising the step of maintaining said model where said model comprises a data structure of at least a portion of said plurality of associated processes in said circuitry wherein said data structure comprises an ABOI matrix of the form:

where A and B represent measurable characteristics of a modeled process and where I is an identity matrix and O is a null matrix and wherein data structure comprises a feedback vector of the form:

where X k and U k represent states of said modeled process and where k is a time period.

9. The method of operation set forth in claim 8, wherein said model includes a mathematical representation of at least a portion of said at least one process of said plurality of associated processes, said mathematical representation defining relationships among inputs and outputs of said at least one process of said associated processes, wherein said mathematical relationship is of the form:

where Z k represents a state space vector of the form::
and said method further comprises the step of using said model iteratively by said processor to populate ones of said plurality of accessible fields of said data structure with said range of possible values of said at least one measurable characteristic, wherein said model gives a prediction form for any point p in the future and wherein said prediction is of the form:

10. The method of operation set forth in claim 6, wherein said model includes at least one feedback variable representing, at feast in part, an output of said at least one process of said associated processes, and said method further includes the step of using said processor, in response to said at least one feedback variable of said at least one process of said associated processes, to populate at least one of said plurality of accessible fields of said data structure.