# Patent

## Title
Stabilized deteministic optimization based control system and method

## Abstract

The embodiments described herein include one embodiment that provides a control method, including determining a first stabilizing feasible control trajectory of a plurality of variables of a controlled process, determining a second stabilizing feasible control trajectory for the plurality of variables for a second time step subsequent to the first time step, determining a first cost of applying the first feasible control trajectory at the second time step, determining a second cost of applying the second feasible control trajectory at the second time step, comparing the first and second costs, selecting the first feasible control trajectory or the second feasible control trajectory based upon the comparison in a predetermined time frame, and controlling the controlled process by application of the selected control trajectory.

## Background
BACKGROUND
The invention relates generally to control systems and more particularly to deterministic optimization based control of systems.
Generally, control system, such as an industrial plant or a power generation system, may be dynamic and include various constraints. For example, the constraints on the control system may be the result of actuator limits, operational constraints, economical restrictions, and/or safety restrictions. Accordingly, control of such a multivariable constrained dynamic system may be complex. Techniques such as coupled multi-loop proportional-integral-derivative (PID) controllers may not be best suited for handling the control of such complex control systems. On the other hand, one process control technique capable of handling the multivariable constraints is optimization based control (OBC). Specifically, OBC may improve the performance of the control system by enabling the system to operate closer to the various constraints (i.e., via dynamic optimization).
However, OBC may be computationally demanding because the dynamic optimization calculation may involve solving a constrained optimization problem such as quadratic programming (QP) problems at each sampling time. Utilizing a general solver may take seconds or even minutes. In addition, it may be difficult to predict the time it takes for the optimizer to solve the constrained optimization problems. Accordingly, to utilize OBC to control systems with faster dynamics, it may often be beneficial to enable deterministic OBC to provide a feasible control action within a predetermined control time.
BRIEF DESCRIPTION
Certain embodiments commensurate in scope with the originally claimed invention are summarized below. These embodiments are not intended to limit the scope of the claimed invention, but rather these embodiments are intended only to provide a brief summary of possible forms of the invention. Indeed, the invention may encompass a variety of forms that may be similar to or different from the embodiments set forth below.
A first embodiment provides a control method including determining a first stabilizing feasible control trajectory of a plurality of variables of a controlled process, the first control trajectory being the same as or an extension of a control trajectory applied for a first time step, the trajectory extending over a plurality of future time steps after the first time step, determining a second stabilizing feasible control trajectory for the plurality of variables for a second time step subsequent to the first time step, determining a first cost of applying the first feasible control trajectory at the second time step, determining a second cost of applying the second feasible control trajectory at the second time step, comparing the first and second costs, selecting the first feasible control trajectory or the second feasible control trajectory based upon the comparison in a predetermined time frame, and controlling the controlled process by application of the selected control trajectory.
A second embodiment provides a control method, comprising a first stabilizing feasible control trajectory of a plurality of variables of a controlled process for a second time step within a predetermined time frame based upon a control trajectory applied for a first time step previous to the second time step, the trajectory extending over a plurality of future time steps after the first time step, applying an optimization-based control algorithm to determine a second feasible control trajectory for a second time step, selecting the first feasible control trajectory if a first cost of applying the first feasible control trajectory is less then a second cost of applying the second feasible control trajectory, or if the optimization-based control algorithm does not determine a second feasible control trajectory in a time allowed, and controlling the controlled process by application of the selected control trajectory.
A third embodiment provides a control system, including memory circuitry for storing executable code, and processing circuitry for executing the code. The code defining steps that, when executed determines a first stabilizing feasible control trajectory of a plurality of variables of a controlled process, the first control trajectory being the same as or an extension of a control trajectory applied for a first time step, the trajectory extending over a plurality of future time steps after the first time step, determines a second feasible control trajectory for the plurality of variables for a second time step subsequent to the first time step, determines a first cost of applying the first feasible control trajectory at the second time step, determines a second cost of applying the second feasible control trajectory at the second time step, compares the first and second costs, selects the first feasible control trajectory or the second feasible control trajectory based upon the comparison within a predetermined time frame, and controls the controlled process by application of the selected control trajectory.



DRAWINGS
These and other features, aspects, and advantages of the present invention will become better understood when the following detailed description is read with reference to the accompanying drawings in which like characters represent like parts throughout the drawings, wherein:
FIG. 1 depicts a block diagram of an embodiment of a control system utilizing deterministic optimization-based control (OBC);
FIG. 2 depicts a block diagram of an embodiment of the deterministic optimization-based control from FIG. 1;
FIG. 3 depicts a block diagram of an embodiment of the processing circuitry from FIG. 2;
FIG. 4 depicts an embodiment of a deterministic OBC module communicatively coupled to other modules within the control system.
FIG. 5A depicts an embodiment of a feasible search method for solving a quadratic programming problem that has found an optimum solution;
FIG. 5B depicts an embodiment of a feasible search method for solving the quadratic programming problem that has not found the optimum solution;
FIG. 5C depicts an embodiment of an infeasible search method for solving the quadratic programming problem that has found the optimum solution;
FIG. 6 depicts a block diagram of an embodiment of a stabilization process used in the optimization-based control;
FIG. 7A depicts a first feasible solution for the quadratic programming problem;
FIG. 7B depicts the first feasible solution advanced one step compared to a second feasible solution for the quadratic programming problem;
FIG. 8 depicts an embodiment of a process control utilizing the stabilization process depicted in FIG. 6;
FIG. 9 depicts an embodiment of dynamic optimization-based control (OBC) utilizing a steady state block, a dynamic target generator block, and a dynamic optimization block;
FIG. 10 depicts an embodiment of dynamic optimization-based control (OBC) utilizing a steady state block and a dynamic target generator block;
FIG. 11 depicts an embodiment of dynamic optimization-based control (OBC) utilizing a dynamic optimization block; and
FIG. 12 depicts an approximation based on control blocking compared to one based on linear control blocking;
FIG. 13A depicts an embodiment of complex constraints; and
FIG. 13B depicts and embodiments simple bound constraints acting as a funnel for the complex constraints.



DETAILED DESCRIPTION
One or more specific embodiments of the present invention will be described below. In an effort to provide a concise description of these embodiments, all features of an actual implementation may not be described in the specification. It should be appreciated that in the development of any such actual implementation, as in any engineering or design project, numerous implementation-specific decisions must be made to achieve the developers' specific goals, such as compliance with system-related and business-related constraints, which may vary from one implementation to another. Moreover, it should be appreciated that such a development effort might be complex and time consuming, but would nevertheless be a routine undertaking of design, fabrication, and manufacture for those of ordinary skill having the benefit of this disclosure.
When introducing elements of various embodiments of the present invention, the articles “a,” “an,” “the,” and “said” are intended to mean that there are one or more of the elements. The terms “comprising,” “including,” and “having” are intended to be inclusive and mean that there may be additional elements other than the listed elements.
The present disclosure is generally directed toward systems and methods for deterministic optimization-based control (OBC) of a control system, such as an industrial plant, a power generation system, or the like. Generally, control systems may utilize process control techniques to control the system. For example, some control systems utilize proportional-integral-derivative (PID) controllers coupled in a multi-loop configuration. Multi-loop PID controllers may offer a fast real-time control of a control system. In addition, PID controllers may run on embedded systems with less computational power. However, when control system has complex dynamics and/or its operation is constrained, the complexity of the process control may greatly increase and multi-loop PID controllers may not provide adequate control. For example, the control system may include processes with large dead times or non-minimum phase dynamics.
One process control technique for control of dynamic multivariable systems is optimization-based control (OBC), which can offer better control (e.g. reduces process variations to enable operation closer to constraints at more profitable operating points). Specifically, OBC uses a process model to predict future process output trajectories based on process input trajectories. In other words, OBC computes trajectories of manipulated variables to optimize the objective function (i.e., minimize costs). As used herein, the cost includes the determination of how well the output trajectories match the desired setpoints. It should be appreciated that in linear control systems, the cost may be captured as a quadratic programming (QP) problem. Accordingly, the dynamic optimization included in the OBC may be computationally complex and run on computer servers with general solvers, which may take seconds or even minutes to produce a solution. Thus, to include OBC on an embedded system for real-time process control, it may be beneficial to improve the efficiency of OBC while ensuring that it is stabilizing.
Accordingly, one embodiment provides a control method including determining a linear approximation of a pre-determined non-linear model of a process to be controlled, determining a convex approximation of the nonlinear constraint set, determining an initial stabilizing feasible control trajectory for a plurality of sample periods of a control trajectory, executing an optimization-based control algorithm to improve the initial stabilizing feasible control trajectory for a plurality of sample periods of a control trajectory, and controlling the controlled process by application of the feasible control trajectory within a predetermined time window. In other words, deterministic OBC may be utilized for real-time control of systems with fast dynamics by including a stabilization function to produce a stable feasible solution (i.e., a solution that does not increase the cost function) available for each predetermined sampling time.
By way of introduction, FIG. 1 depicts an embodiment of a control system 10 for a plant/process 12. Generally, the control system 10 may control the functioning of the plant/process 12, which may be an industrial manufacturing system, an automation system, a power generation system, a turbine system, or the like. Accordingly, as depicted, the control system 10 may control the plant/process 12 to transform material inputs 14 into material outputs 16. For example, the plant/process 12 may be a sugar crystallization process that transforms sugar syrup (i.e., material input 14) into sugar crystals (i.e., material output 16). In addition, the control system 10 may control the output variables (i.e., controlled variables) 18 by manipulating the input variables 20 (i.e., manipulated and disturbance variables). Going back to the sugar crystallization example, the control system 10 may manipulate a steam valve (i.e., manipulated variable) to control a temperature (i.e., controlled variable). In some embodiments, the material input can be a manipulated variable as well (for example a controller can control the feed rate for a material input to the plant).
To optimize the control of the plant/process 12, the control system 10 may further include optimization based control (OBC) 22 configured to find a stabilizing feasible solution for an optimization problem within a predetermined time window. In other words, the OBC 22 may determine feasible actions (i.e., solution) for the control system 10 to take. Specifically, the OBC 22 may be configured to determine a control trajectory 26 (i.e., a set of actions) over a control horizon (i.e., period of time to take the actions). Accordingly, the OBC 22 may sample the state of the plant/process 12 at specified sampling times. In some embodiments, the state of the plant/process 12 may include the previous output variables 18, a desired output trajectory 23, a desired control trajectory 24, or any combination thereof. Based on the sampled state of the plant/process 12, the OBC 22 may determine the control trajectory 26 (i.e., a feasible solution to the optimization problem) during the control time. As used herein, control time refers to the time during which the plant/process 12 is functioning, which may be in real-time. After the control trajectory 26 is determined by the OBC 22, in some embodiments, the control trajectory 26 is compared to the desired control trajectory 24 in a comparator 32 to determine the input variables 20 to the plant/process 12 (i.e., actions to be taken in the control system 10). Alternatively, the control trajectory 26 may be directly reflected in the input variables 20. It should be appreciated that the OBC 22 may be implemented on an embedded system, such as ControlLogix, available from available from Rockwell Automation, of Milwaukee, Wis.
To facilitate determining the control trajectory 26, as depicted, the OBC 22 includes a pre-determined model 28 and a deterministic solver 30. Specifically, the deterministic solver 30 may use a feasible search strategy, such as a primal active set method, to determine solutions to the constrained optimization problem. As will be described in more detail below, a feasible search strategy begins at a starting point within the feasible region of the control system 10 and moves around the feasible region to search for an optimum feasible solution (i.e., control trajectory with minimum cost). In other words, the deterministic solver 30 may determine various feasible actions (i.e., control trajectories) that may be taken by the control system 10. Based on the feasible solutions determined by the deterministic solver 30, the model 28 may be utilized to predict the behavior of the process/plant 12. In linear systems or non-linear systems with a linear approximation, the model 28 may be a linear model such as a state space model, a step or impulse response model, an autoregressive with exogenous terms (ARX) model, a transfer function model, or the like. As such, the OBC 22 may compare the cost of each feasible solution and select the control trajectory 26 with the lowest cost.
Ideally, the control trajectory 26 determined is the optimum solution with the lowest cost associated, but, as described above, the optimization calculation may be complex. Accordingly, as will be described in further detail below in the Detailed Example section, the techniques described herein aim to increase the efficiency of the dynamic optimization calculation. For example, the techniques described herein may modify an objective (i.e., cost) function to define the control system 10 constraints with simple bounds. Thus, the dynamic optimization computation may be greatly reduced and executed on an embedded system because many dynamic optimization solvers (e.g., quadratic-programming (QP) solvers) more efficiently handle simple bounds compared to complex constraints.
Although the dynamic optimization may be efficiently configured, the OBC 22 may not always find the optimum (i.e., lowest cost) control trajectory 26 during each control time. However, in practice, a stable sub-optimal control trajectory 26 may be sufficient. As used herein, the control trajectory 26 is stabilizing when the cost does not increase compared to the previous step by taking the actions.
To facilitate the functions described herein, it should be appreciated that the OBC 22 may include a processor, useful for executing computing instructions (i.e., steps), and memory, useful for storing computer instructions (i.e., code) and/or data. As depicted in FIG. 2, the OBC 22 may implement the processor through processing circuitry 34 and the memory through memory circuitry 36. More specifically, the processing circuitry 34 may be configured to handle the general functionality of the control system, such as controlling actuators, as well as the functions of OBC 22, such as dynamic optimization. In addition, as depicted in FIG. 3, the processing circuitry 34 may include multiple processing components (e.g., parallel processor cores or separate processor modules), which may enable the processing circuitry 34 to better manage various functions. For example, as depicted, a first processing component 38 may perform the general operations of the control system 10. The general operations of the control system 10 may include controlling components of the control system 10, performing calculations, and the like. As for the OBC 22 functions, the computationally intensive dynamic optimization may be performed on the second processing component 40. Accordingly, this enables the dynamic optimization to be called from the first processing component 38 and executed synchronously or asynchronously on the second processing component 40, which may improve the efficiency of the optimization calculation. Alternatively, it should be appreciated that the dynamic optimization may be performed on the first processing core 38 along with the general functions of the control system 10. Furthermore, as depicted, the processing circuitry 34 includes N processing components, which may each be configured to handle different functions, such as calculating a linear approximation, of the control system 10.
Turning back to FIG. 2, the memory circuit 36 may store computer instructions (i.e., code) describing the model 28, the deterministic solver 30, configuration parameters 42, as well as other instructions 44, such as computing virtual measurements for unmeasured process variables for the general functioning of the control system 10. Specifically, the instructions stored in the memory circuit may be configured to guide the functioning of the model 28 and the deterministic solver 30. Accordingly, the memory circuitry 36 is communicatively coupled to the processing circuitry 34 to enable to processing circuitry 36 to read and/or execute the instructions (i.e., steps).
Furthermore, the depicted embodiment of the OBC 22 further includes an output interface 46, a user interface 48, a network interface 50, and a feedback interface 52. Specifically, the user interface 48 may be configured to enable a user to communicate with the OBC 22. For example, as depicted in FIG. 4, the user interface 48 may include a graphical-user-interface (GUI) 54 configured to display metrics of the OBC 22, such as the control trajectory 26 determined. In addition, the user interface 48 may include buttons 56, which enable the user to input commands to the OBC 22. Similar to the user interface 48, the network interface 50 may enable a user to communicate with the OBC 22 over a network 58, such as a wide-area-network (WAN). In some embodiments, the network 58 may be a EtherNet/IP Network or a ControlNet Network, available from Rockwell Automation, of Milwaukee, Wis. More specifically, as depicted in FIG. 4, the network interface 50 may be communicatively coupled to the network 58 via a communication module 60. Alternatively, the network interface 50 may be communicatively coupled directly the network 58 through the backplane of the OBC 22. Furthermore, as depicted, the network 58 may be communicatively coupled to a remote monitoring/control system 62, such as a supervisory control and data acquisition (SCADA), to enable the user to remotely communicate with the OBC 22. Accordingly, as depicted in FIG. 2, both the user interface 48 and the network interface 50 are communicatively coupled to the processing circuitry 34 to enable user commands to be communicated to the processing circuitry 34 and information concerning the OBC 22 to be communicated to the user. Note that each module in memory circuitry 36 may be configured such that it can respond as a server responding to the queries from various interfaces. For example, the model module 28 can be queried by the user interface to report its fidelity. In addition the model module 28 may be called by solver code module 30 to determine the optimal control trajectory.
Turning back to FIG. 2, as described above, the OBC 22 may be configured determine stabilizing feasible control trajectories for the control system 10 based on feedback from the plant/process 12. As such, the feedback interface 52 may be configured to receive feedback, such as the previous output variables 18, the desired output trajectory 23, the desired control trajectory 24, or any combination thereof, and communicate it to the processing circuitry 34. For example, the feedback interface 52 may be a serial port located on the backplane of the OBC 22, which enables the OBC 22 to receive samples from sensors in the control system 10. After the processing circuitry 34 determines a control trajectory 26, the control trajectory 26 is communicated to the output interface 46. As will be described in more detail below, the processing circuitry 34 may utilize various search functions (e.g., QP solvers) and stabilization functions to determine the control trajectory 26. Thus, the output interface 46 may be configured to transmit the control trajectory 26 to the plant/process 12. Similar to the feedback interface 52, the output interface 46 may be a serial port located on the backplane of the OBC 22 to enable the output interface to communicate with a controller controlling inputs into the plant/process 12. It should be appreciated that as described above, the controller may be the same processing component, a different core of a processor, or a different processor module.
As described above, the processing circuitry may utilize various search methods to facilitate determining a control trajectory 26 (i.e., dynamic optimization). Examples of such search methods are depicted in FIGS. 5A-5C. Included in each figure, as depicted, is a feasible region 64 and an infeasible region 66. More specifically, the feasible region 64 is all of the solutions or control trajectories 26 that do not violate the constraints of the control system 10. On the other hand, the solutions or control trajectories 66 in the infeasible region violate the constraints of the control system 10 and are infeasible. As depicted, constraints are depicted as constraint lines 68, which separate the feasible region 64 and the infeasible region 66. As described above, the constraints may be the result of actuator limits, technological restrictions, economical restrictions, and/or safety restrictions.
As described above, the processing circuitry 34 may utilize various solver methods (i.e., algorithms) to facilitate determining a control trajectory 26 (i.e., dynamic optimization). Examples of such solver methods are depicted in FIGS. 5A-5C. Included in each figure, as depicted, is a feasible region 64 and an infeasible region 66. More specifically, the feasible region 64 is all of the solutions or control trajectories 26 that do not violate the constraints of the control system 10. On the other hand, the solutions or control trajectories 66 in the infeasible region violate the constraints of the control system 10 and are infeasible. As depicted, constraints are depicted as constraint lines 68, which separate the feasible region 64 and the infeasible region 66. As described above, the constraints may be the result of actuator limits, technological restrictions, economical restrictions, and/or safety restrictions.
Specifically, FIGS. 5A and 5B depict feasible search methods (i.e., algorithms) and FIG. 5C depicts an infeasible search method (i.e., algorithms). However, it should be appreciated that the figures are not meant to depict any particular search method or algorithm and are merely illustrative. As depicted in both FIG. 5A and FIG. 5B, the feasible search method begins from a feasible point 70 within the feasible region 64. From the starting feasible point 70, the feasible search method moves around the feasible region 64 searching for the optimum solution (i.e., control trajectory) 72 during the control time. In some cases, as shown in FIG. 5A, an optimum control trajectory 72 is found. In others, as shown in FIG. 5B, a suboptimal but still feasible control trajectory 74 is found. An example of a feasible search method is a primal active set solver method (i.e., algorithm). Comparatively, as depicted in FIG. 5C, the infeasible search method begins from an infeasible point 76 within the infeasible region 66. From the starting infeasible point 76, the infeasible search method determines infeasible solutions until it converges on the optimum solution (i.e., control trajectory) 72. An example of an infeasible search method is a dual active set solver method. Accordingly, it should be appreciated that, if terminated before the optimum control trajectory 72 is found, the feasible search method will produce a feasible control trajectory, but the infeasible search method may produce an infeasible control trajectory.
In addition, as described above, the dynamic optimization (e.g., feasible search method or infeasible search method) may be run asynchronously from the rest of the control system 10. Thus, if a less than optimum control trajectory is found during the control time, the optimization may continue into the following control times, which gives the OBC 22 more time for complex optimization calculations. Furthermore, when the optimum trajectory 72 is found, it may be time shifted, padded, and included in future optimization calculations.
Because in some embodiments the dynamic optimization calculation may find a suboptimal control trajectory 74 during the control time, a stabilization process 78 may be useful to stabilize the control system 10. In other words, the stabilization process 78 may be configured to reduce the risk that the cost of the control system 10 will increase because of the suboptimal control trajectory 74. As depicted in FIG. 6, the stabilization process 78 may begin by computing a feasible solution or control trajectory (process block 80). The feasible solution may be calculated in various manners. For example, as will be described in more detail below, a steady state optimization method may be used. Alternatively, other search methods, such as the primal active set solver method, may be used.
To stabilize the control system 10, the feasible solution determined in process block 80 (i.e., first stabilizing control trajectory) may be compared to a previous solution (i.e., second stabilizing control trajectory) determined in process block 84. More specifically, the previous solution is advanced, which may include shifting and padding, to the next control time (process block 86). As an example, FIG. 7A depicts a control trajectory 88 with a control horizon of six (i.e., six time steps) determined at a time i. As described above, the control trajectory 88 represents a setting of a manipulated variable, such as the percent a valve is open. Accordingly, based on the control trajectory 88, the control system 10 will take a first action 90 for the control time between time i and time i+1. At time i+1, the first action 90 has been performed. Thus, as depicted in FIG. 7B, the remaining control trajectory 88 (i.e., trajectory between time i+1 and time i+6) is time shifted to form a previous solution 92. In addition, because the control horizon for the time shifted control trajectory is five (i.e., five time steps), the previous solution is 92 is padded with an additional control system action 94. In some embodiments, this may include repeating the last control system action 96. Furthermore, FIG. 7B depicts a newly calculated solution 98, such as by process block 80, represented by the dashed line. Accordingly, the previous solution 92 may be compared to the newly calculated solution 98.
Turning back to FIG. 6, after the previous solution 92 and the newly calculated solution 98 are adjusted to the same control horizon, one characteristic to be compared may be the cost of each. Accordingly, based on the objective (i.e., cost) function, the cost for the newly calculated solution 98 (process block 99) and the cost of the previous solution 92 may be calculated (process block 100). Next, the cost of the new solution 98 is compared with the cost of the previous solution 92 (process block 102). Finally, the solution (i.e., control trajectory) with the lowest cost may be selected (process block 104).
As will be described in more detail below, the selected control trajectory may be utilized by the control system 10 to control the plant/process 12 by applying the selected control trajectory. For example, the selected control trajectory may be used directly to control the manipulated variables 20 input into the plant/process 12. Alternatively, as depicted in FIG. 8 the selected control trajectory may be used to in a stable deterministic optimization based control (OBC) process (i.e., algorithm) 106, which may be implements in the OBC 22. Beginning the process 106, user-defined setpoints 107 and/or feasible targets (i.e., infeasible setpoints mapped into feasible region) 108 may be input into an initial (i.e., upstream) processing, which may be configured to determine a feasible solution or control trajectory (process block 110). As described above, the initial processing (process block 110) may utilize any method to determine a feasible solution (i.e., control trajectory). Next the stabilization process may stabilize the control system 10 (process block 78). The solution selected by the stabilization process 78, may then be used to initialize a dynamic optimization (process block 112). This may be helpful especially when input into a feasible search method, which utilizes a feasible starting solution. For example, as will be described in more detail in the Detailed Example section, initializing a primal active set solver method (i.e., algorithm) with the solution selected by the stabilization process 78 may increase the efficiency of the optimization search 112. Finally, based on the control trajectory determined by the optimization search 112, the manipulated variables 20 input into the plant/process 12 may be controlled (process block 114).
FIGS. 9-11 depict different embodiments of OBCs 22 utilizing the stable deterministic optimization based process control 106. Included in the three embodiments are three optional and configurable blocks: a steady state optimization block 116, a dynamic target generation block 118, and a dynamic optimization block 120. Accordingly, a user may choose an appropriate configuration of the OBC 22 that fits the specific needs of particular application in terms of closed loop performance, robustness and/or execution speed.
The steady state optimization block 116 can have two different purposes. The first goal of the steady state optimization block 116 is to find the most profitable steady-state control target based on the model 28 and the user-defined setpoints 107. The second goal of the steady state optimization block 116 is to find feasible steady-state targets that are as close to infeasible setpoints as possible, which may then be used in the dynamic optimization 112. In some embodiments, the steady-state target is a control trajectory with a single operating point. Furthermore, in some embodiments, the steady state optimization block 116 may account for control variable zones. In other words, a zone setpoint instead of a particular point. More specifically, the steady state optimization block may utilize soft constraints.
The dynamic target generation block 118 may be configured to generate feasible dynamic control trajectories based on the user-defined setpoints 107, feasible targets 108, and/or the steady-state targets. Accordingly, the effect of procrastination may be reduced and robustness may be satisfactory. As used herein, procrastination refers to a predicted control trajectory that is infeasible and thus not applied. For example, the dynamic target generation block 118 may be configured to generate feasible control trajectories by starting at each infeasible setpoint and terminating at the feasible target 108. In addition, the dynamic optimization block 120 may be configured to implement the dynamic optimization process 112. Furthermore, as depicted in FIGS. 9-11, each embodiment includes the stabilization process 78.
FIG. 9 depicts an embodiment including the steady state optimization block 116, the dynamic target generation block 118, and the dynamic optimization block 120. In the depicted embodiment, the steady state optimization block 116, using a primal active set solver method (i.e., algorithm), is configured to determine steady-state targets 124. Next, the dynamic target generation block 118 is configured to generate, by filter combining, a feasible dynamic control trajectory 126. Accordingly, in the present embodiment, the steady state optimization block 116 and the dynamic optimization block 120 make up the initial processing 110. Thus, the stabilization process 78 may stabilize the control system 10 as described above. Based on the output (i.e., selected feasible control trajectory) from the stabilization process 78, the dynamic optimization block 120 may attempt to find the optimum solution (i.e., control trajectory). For example, the depicted embodiment uses the primal active set solver method (i.e., algorithm) 122. The OBC 22 embodiment depicted in FIG. 9 may be the most universal but the slowest configuration.
FIG. 10 depicts an embodiment including the steady state optimization block 116 and the dynamic target generation block 118. Similar to the embodiment depicted in FIG. 9, the depicted embodiment the steady state optimization block generates the steady state targets 124, the dynamic target generation block 118 generates a feasible dynamic control trajectory 126, and the stabilization process 78 stabilizes the control system 10. In this embodiment, the feasible control trajectory selected by the stabilization process 78 is directly passed to the control system 10. The OBC 22 embodiment depicted in FIG. 10 may be a good option for time critical applications.
FIG. 11 depicts an embodiment including the dynamic optimization block 120. In the depicted embodiment, the stabilization process 78 uses the user-inputted setpoint 107 as a control trajectory. Similar to the embodiment depicted in FIG. 9, based output from the stabilization process 78, the dynamic optimization block 120 may attempt to find the optimum solution (i.e., control trajectory). The OBC 22 embodiment depicted in FIG. 11 may be used for small scale applications with good closed loop performance.
DETAILED EXAMPLE
Below is a detailed example to help illustrate the techniques taught herein. First, as described above, the efficiency of the OBC 22 may be increased by simplifying the dynamic optimization calculation. In some embodiments, this may include simplifying the model 28. Generally, the model 28 may be expressed as a standard formula.

y=AuΔu+yfree  (1)

where

Δu=[(Δu1)T, (Δu2)T, . . . , (Δunu)T]T—future changes of all inputs arranged in a vector
Δun=[Δun (t), Δun (t+1), . . . , Δun (t+nc−1)]T—future changes of n-th input
y=[(y1)T, (y2)T, . . . , (yny)T]T—all predicted output trajectories arranged in a vector
yj=[yj (t+1), . . . , yj (t+p)]T—predicted trajectory of j-th output
yfree=[(yfree1)T, (yfree2)T, . . . , (yfreeny)T]T—all free response trajectories arranged in a vector
yfreej=[yfreej (t+1), . . . , yfreej (t+p)]T—free response trajectory of j-th output
nu—number of inputs
ny—number of outputs
nc—control horizon
p—prediction horizont
N=nc—number of control moves
Specifically, the standard formula (equation 1) reflects the superposition principle: the total future response (i.e., output trajectory) is a sum of responses to future inputs and responses to past inputs, disturbances, and initial conditions (i.e., yfree). The response yfree, may be updated at each sample time according to particular model structure. Accordingly, the predicted output trajectory of the j-th output may be expressed similar to equation 1.

yj=AujΔu+yfreej  (2)

where

Auj=[Auj1, Auj2, . . . , Aujnu]—prediction matrix of j-th output
Au=[Au1T, Au2T, . . . , AunyT]T—prediction matrix
Furthermore, the following equation represents the changes of inputs (i.e., incremental inputs).

Δu(k)=u(k)−u(k−1)  (3)

In addition, the following represent the absolute inputs.

un=[un(t), un (t+1), . . . , un (t+nc−1)]T—future trajectory of n-th input

u=[(u1)T, . . . , (u2)T, . . . , (unu)T]T—all future input trajectories arranged in a vector)  (4)

Thus, to help simplify the above equations, relative inputs may be used instead of incremental inputs. Specifically, the constraints may be simplified and the Hessian matrix may be better conditioned. As used herein ur represents the relative input and is defined as difference from current value of input. Accordingly, ur may be expressed as follows.

uri(k)=ui(k)−u0i  (5)

where

uri—i-th relative input
u0i=ui(t−1)—current value of the i-th input
Based on the definition of un, equation (5) may alternatively expressed as follows.

uri=ui−1u0i, 1T=[1,1, . . . 1]T  (6)

Thus, the linear transformation between the relative input (ur) and the incremental input (Δu) is as follows.




  
    
      
        
          
            
              Δ
              ⁢
              
                
              
              ⁢
              
                
                  u
                  i
                
                ⁡
                
                  (
                  k
                  )
                
              
            
            =
            
              
                
                  
                    u
                    i
                  
                  ⁡
                  
                    (
                    k
                    )
                  
                
                -
                
                  
                    u
                    i
                  
                  ⁡
                  
                    (
                    
                      k
                      -
                      1
                    
                    )
                  
                
              
              =
              
                
                  Δ
                  ⁢
                  
                    
                  
                  ⁢
                  
                    
                      u
                      ri
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                
                =
                
                  
                    
                      u
                      ri
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  -
                  
                    
                      u
                      ri
                    
                    ⁡
                    
                      (
                      
                        k
                        -
                        1
                      
                      )
                    
                  
                
              
            
          
          ⁢
          
            

          
          ⁢
          
            
              
                u
                ri
              
              ⁡
              
                (
                k
                )
              
            
            =
            
              
                ∑
                
                  j
                  =
                  t
                
                k
              
              ⁢
              
                Δ
                ⁢
                
                  
                
                ⁢
                
                  
                    u
                    i
                  
                  ⁡
                  
                    (
                    j
                    )
                  
                
              
            
          
          ⁢
          
            

          
          ⁢
          
            
              u
              ri
            
            =
            
              S
              ⁢
              
                
              
              ⁢
              Δ
              ⁢
              
                
              
              ⁢
              
                u
                i
              
            
          
          ,
          
            

          
          ⁢
          
            S
            =
            
              [
              
                
                  
                    1
                  
                  
                    0
                  
                  
                    0
                  
                  
                    ...
                  
                  
                    0
                  
                
                
                  
                    1
                  
                  
                    1
                  
                  
                    0
                  
                  
                    
                      
                    
                  
                  
                    0
                  
                
                
                  
                    1
                  
                  
                    1
                  
                  
                    1
                  
                  
                    
                      
                    
                  
                  
                    0
                  
                
                
                  
                    ⋮
                  
                  
                    
                      
                    
                  
                  
                    
                      
                    
                  
                  
                    ⋱
                  
                  
                    0
                  
                
                
                  
                    1
                  
                  
                    1
                  
                  
                    1
                  
                  
                    1
                  
                  
                    1
                  
                
              
              ]
            
          
          ,
          
            

          
          ⁢
          
            
              Δ
              ⁢
              
                
              
              ⁢
              
                u
                i
              
            
            =
            
              
                
                  S
                  ⁢
                  
                    
                  
                
                
                  -
                  1
                
              
              ⁢
              
                u
                ri
              
            
          
          ,
          
            

          
          ⁢
          
            
              S
              
                -
                1
              
            
            =
            
              [
              
                
                  
                    1
                  
                  
                    0
                  
                  
                    0
                  
                  
                    ...
                  
                  
                    0
                  
                
                
                  
                    
                      -
                      1
                    
                  
                  
                    1
                  
                  
                    0
                  
                  
                    
                      
                    
                  
                  
                    0
                  
                
                
                  
                    0
                  
                  
                    
                      -
                      1
                    
                  
                  
                    1
                  
                  
                    
                      
                    
                  
                  
                    0
                  
                
                
                  
                    ⋮
                  
                  
                    
                      
                    
                  
                  
                    
                      
                    
                  
                  
                    ⋱
                  
                  
                    ⋮
                  
                
                
                  
                    0
                  
                  
                    0
                  
                  
                    ...
                  
                  
                    
                      -
                      1
                    
                  
                  
                    1
                  
                
              
              ]
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              Δ
              ⁢
              
                
              
              ⁢
              u
            
            =
            
              
                
                  S
                  ⁢
                  
                    
                  
                
                c
                
                  -
                  1
                
              
              ⁢
              
                u
                r
              
            
          
          ,
          
            

          
          ⁢
          
            
              S
              c
              
                -
                1
              
            
            =
            
              [
              
                
                  
                    
                      S
                      
                        -
                        1
                      
                    
                  
                  
                    0
                  
                  
                    ...
                  
                  
                    0
                  
                
                
                  
                    0
                  
                  
                    
                      S
                      
                        -
                        1
                      
                    
                  
                  
                    
                      
                    
                  
                  
                    0
                  
                
                
                  
                    ⋮
                  
                  
                    
                      
                    
                  
                  
                    ⋱
                  
                  
                    
                      
                    
                  
                
                
                  
                    0
                  
                  
                    0
                  
                  
                    
                      
                    
                  
                  
                    
                      S
                      
                        -
                        1
                      
                    
                  
                
              
              ]
            
          
          ,
          
            

          
          ⁢
          
            
              u
              r
            
            =
            
              
                S
                c
              
              ⁢
              Δ
              ⁢
              
                
              
              ⁢
              u
            
          
          ,
          
            

          
          ⁢
          
            
              S
              c
            
            =
            
              [
              
                
                  
                    S
                  
                  
                    0
                  
                  
                    ...
                  
                  
                    0
                  
                
                
                  
                    0
                  
                  
                    S
                  
                  
                    
                      
                    
                  
                  
                    0
                  
                
                
                  
                    ⋮
                  
                  
                    
                      
                    
                  
                  
                    ⋱
                  
                  
                    
                      
                    
                  
                
                
                  
                    0
                  
                  
                    0
                  
                  
                    
                      
                    
                  
                  
                    S
                  
                
              
              ]
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              u
              r
            
            =
            
              u
              =
              
                
                  I
                  c
                
                ⁢
                
                  u
                  0
                
              
            
          
          ,
          
            

          
          ⁢
          
            
              I
              c
            
            =
            
              [
              
                
                  
                    1
                  
                  
                    0
                  
                  
                    ...
                  
                  
                    0
                  
                
                
                  
                    0
                  
                  
                    1
                  
                  
                    
                      
                    
                  
                  
                    0
                  
                
                
                  
                    ⋮
                  
                  
                    
                      
                    
                  
                  
                    ⋱
                  
                  
                    
                      
                    
                  
                
                
                  
                    0
                  
                  
                    0
                  
                  
                    
                      
                    
                  
                  
                    1
                  
                
              
              ]
            
          
          ,
          
            

          
          ⁢
          
            
              u
              0
            
            =
            
              [
              
                
                  
                    
                      u
                      01
                    
                  
                
                
                  
                    
                      u
                      02
                    
                  
                
                
                  
                    ⋮
                  
                
                
                  
                    
                      u
                      
                        0
                        ⁢
                        
                          n
                          u
                        
                      
                    
                  
                
              
              ]
            
          
        
        ⁢
        
          

        
        ⁢
        
          u
          =
          
            
              
                S
                c
              
              ⁢
              Δ
              ⁢
              
                
              
              ⁢
              u
            
            +
            
              
                I
                c
              
              ⁢
              
                u
                0
              
            
          
        
      
    
    
      
        (
        7
        )
      
    
  




Accordingly, the model 28 (i.e., equation 1) based on the relative input may be expressed as follows.

y=AuΔu+yfree=(AuSc−1)ur+yfree=Arur+yfree  (8)

To further simplify and improve the model 28, linear control blocking may be utilized. Generally, control blocking may simplify model 28 by changing control inputs at specified control times (i.e., t+cj). In other words, control blocking results in a piece-wise constant control trajectory. To better approximate general smooth control trajectories linear control blocking may be utilized. Specifically, linear control blocking may result in a piece-wise linear control trajectory while the number of decision variables remains the same. For example, as in FIG. 12, the break points 128 of the piece-wise linear trajectory 130 is specified at the following sample times (t+k1), (t+k2), . . . , (t+kN) where k1=0 and kN=nc−1. The decision vector for implementing linear control blocking (uL) is given by the values of relative input (ur) at the specified sample times.

uL=[ur(t),ur(t+k2), . . . ,ur(t+kN)]T  (9)

Accordingly, the values between the break points 128 may be calculated by linear interpolation as follows.




  
    
      
        
          
            u
            r
          
          ⁡
          
            (
            i
            )
          
        
        =
        
          {
          
            
              
                
                  
                    
                      
                        
                          -
                          
                            
                              i
                              -
                              
                                (
                                
                                  t
                                  +
                                  
                                    k
                                    
                                      j
                                      +
                                      1
                                    
                                  
                                
                                )
                              
                            
                            
                              
                                k
                                
                                  j
                                  +
                                  1
                                
                              
                              -
                              
                                k
                                j
                              
                            
                          
                        
                        ⁢
                        
                          
                            u
                            L
                          
                          ⁡
                          
                            (
                            
                              t
                              +
                              
                                k
                                j
                              
                            
                            )
                          
                        
                      
                      +
                      
                        
                          
                            i
                            -
                            
                              (
                              
                                t
                                +
                                
                                  k
                                  j
                                
                              
                              )
                            
                          
                          
                            
                              k
                              
                                j
                                +
                                1
                              
                            
                            -
                            
                              k
                              j
                            
                          
                        
                        ⁢
                        
                          
                            u
                            L
                          
                          ⁡
                          
                            (
                            
                              t
                              +
                              
                                k
                                
                                  j
                                  +
                                  1
                                
                              
                            
                            )
                          
                        
                      
                    
                  
                  
                    
                      
                        i
                        ∈
                        
                          [
                          
                            
                              t
                              +
                              
                                k
                                j
                              
                            
                            ,
                            
                              t
                              +
                              
                                k
                                
                                  j
                                  +
                                  1
                                
                              
                            
                          
                          ]
                        
                      
                      ,
                    
                  
                
                
                  
                    
                      
                        
                          u
                          L
                        
                        ⁡
                        
                          (
                          
                            t
                            +
                            
                              k
                              N
                            
                          
                          )
                        
                      
                      ,
                    
                  
                  
                    
                      i
                      ∈
                      
                        [
                        
                          
                            t
                            +
                            
                              k
                              N
                            
                            +
                            1
                          
                          ,
                          
                            t
                            +
                            p
                            -
                            1
                          
                        
                        ]
                      
                    
                  
                
              
              ⁢
              
                

              
              ⁢
              j
            
            =
            
              
                1
                ⁢
                
                  
                
                ⁢
                ...
                ⁢
                
                  
                
                ⁢
                N
                ⁢
                
                  

                
                ⁢
                
                  u
                  r
                
              
              =
              
                
                  [
                  
                    
                      
                        u
                        r
                      
                      ⁡
                      
                        (
                        t
                        )
                      
                    
                    ,
                    
                      
                        u
                        r
                      
                      ⁡
                      
                        (
                        
                          t
                          +
                          1
                        
                        )
                      
                    
                    ,
                    ...
                    ⁢
                    
                      
                    
                    ,
                    
                      
                        u
                        r
                      
                      ⁡
                      
                        (
                        
                          t
                          +
                          p
                          -
                          1
                        
                        )
                      
                    
                  
                  ]
                
                T
              
            
          
        
      
    
    
      
        (
        10
        )
      
    
  




Accordingly, a model using control blocking is represented by control trajectory 132 and a model using linear control blocking is represented by control trajectory 134. It follows that ur(i) can be expressed as a linear combination of the break point values as follows.





  
    
      
        
          
            
              u
              r
            
            ⁡
            
              (
              i
              )
            
          
          =
          
            
              ∑
              
                j
                =
                1
              
              N
            
            ⁢
            
              
                f
                ij
              
              ⁢
              
                
                  u
                  L
                
                ⁡
                
                  (
                  
                    t
                    +
                    
                      k
                      j
                    
                  
                  )
                
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            f
            ij
          
          =
          
            {
            
              
                
                  
                    
                      
                        -
                        
                          
                            i
                            -
                            
                              (
                              
                                t
                                +
                                
                                  k
                                  
                                    j
                                    +
                                    1
                                  
                                
                              
                              )
                            
                          
                          
                            
                              k
                              
                                j
                                +
                                1
                              
                            
                            -
                            
                              k
                              j
                            
                          
                        
                      
                    
                    
                      
                        i
                        ∈
                        
                          [
                          
                            
                              t
                              +
                              
                                k
                                j
                              
                            
                            ,
                            
                              t
                              +
                              
                                k
                                
                                  j
                                  +
                                  1
                                
                              
                            
                          
                          ]
                        
                      
                    
                  
                  
                    
                      
                        
                          i
                          -
                          
                            (
                            
                              t
                              +
                              
                                k
                                
                                  j
                                  -
                                  1
                                
                              
                            
                            )
                          
                        
                        
                          
                            k
                            j
                          
                          -
                          
                            k
                            
                              j
                              -
                              1
                            
                          
                        
                      
                    
                    
                      
                        i
                        ∈
                        
                          [
                          
                            
                              t
                              +
                              
                                k
                                
                                  j
                                  -
                                  1
                                
                              
                            
                            ,
                            
                              t
                              +
                              
                                k
                                j
                              
                            
                          
                          ]
                        
                      
                    
                  
                  
                    
                      1
                    
                    
                      
                        i
                        ∈
                        
                          [
                          
                            
                              t
                              +
                              
                                k
                                N
                              
                              +
                              1
                            
                            ,
                            
                              t
                              +
                              p
                              -
                              1
                            
                          
                          ]
                        
                      
                    
                  
                  
                    
                      0
                    
                    
                      otherwise
                    
                  
                
                ⁢
                
                  

                
                ⁢
                
                  f
                  iN
                
              
              =
              
                {
                
                  
                    
                      
                        
                          
                            
                              i
                              -
                              
                                (
                                
                                  t
                                  +
                                  
                                    k
                                    
                                      N
                                      -
                                      1
                                    
                                  
                                
                                )
                              
                            
                            
                              
                                k
                                N
                              
                              -
                              
                                k
                                
                                  N
                                  -
                                  1
                                
                              
                            
                          
                        
                        
                          
                            i
                            ∈
                            
                              [
                              
                                
                                  t
                                  +
                                  
                                    k
                                    
                                      N
                                      -
                                      1
                                    
                                  
                                
                                ,
                                
                                  t
                                  +
                                  
                                    k
                                    N
                                  
                                
                              
                              ]
                            
                          
                        
                      
                      
                        
                          1
                        
                        
                          
                            i
                            ∈
                            
                              [
                              
                                
                                  t
                                  +
                                  
                                    k
                                    N
                                  
                                  +
                                  1
                                
                                ,
                                
                                  t
                                  +
                                  p
                                  -
                                  1
                                
                              
                              ]
                            
                          
                        
                      
                      
                        
                          0
                        
                        
                          otherwise
                        
                      
                    
                    ⁢
                    
                      

                    
                    ⁢
                    j
                  
                  =
                  
                    
                      1
                      ⁢
                      
                        
                      
                      ⁢
                      ...
                      ⁢
                      
                        
                      
                      ⁢
                      N
                    
                    -
                    1
                  
                
              
            
          
        
      
    
    
      
        (
        11
        )
      
    
  




And, in matrix notation we get the following formula.

ur=FuL,F(i,j)=fij  (12)

As a result, the model 28 may be expressed in the following way without increasing the number of decision variables.

y=AuΔu+yfree=AuS−1ur+yfree=AuS−1FuL+yfree 

AL=AuS−1F 

y=ALuL+yfree  (13)

In addition to simplifying the model 28, the cost function (i.e., objection function) may also be simplified to enhance the efficiency of the OBC 22. Generally, a quadratic objective function may be expressed as follows.




  
    
      
        
          J
          y
        
        =
        
          
            
              ∑
              
                j
                =
                1
              
              
                n
                y
              
            
            ⁢
            
              
                
                  (
                  
                    
                      y
                      j
                    
                    -
                    
                      y
                      j
                      t
                    
                  
                  )
                
                T
              
              ⁢
              
                
                  W
                  j
                
                ⁡
                
                  (
                  
                    
                      y
                      j
                    
                    -
                    
                      y
                      j
                      t
                    
                  
                  )
                
              
            
          
          +
          
            
              ∑
              
                n
                =
                1
              
              
                n
                u
              
            
            ⁢
            
              Δ
              ⁢
              
                
              
              ⁢
              
                u
                n
                T
              
              ⁢
              
                B
                n
              
              ⁢
              Δ
              ⁢
              
                
              
              ⁢
              
                u
                n
              
            
          
          +
          
            
              ∑
              
                n
                =
                1
              
              
                n
                u
              
            
            ⁢
            
              
                
                  (
                  
                    
                      u
                      n
                    
                    -
                    
                      u
                      n
                      T
                    
                  
                  )
                
                T
              
              ⁢
              
                
                  V
                  n
                
                ⁡
                
                  (
                  
                    
                      u
                      n
                    
                    -
                    
                      u
                      n
                      t
                    
                  
                  )
                
              
            
          
        
      
    
    
      
        (
        14
        )
      
    
  




where

Wj, Bn, Vn—positive semidefinite weight matrices (tuning parameters)
yjt=[yjt(t+1), yjt(t+2), . . . , yjt(t+p)]T—output target trajectory
unt=[unt(t+1), unt (t+2), . . . , unt (t+p)]T—input target trajectory
Using standard algebraic manipulation the objective function can be transformed to the following quadratic form.

Jy(Δu)=1⁄2ΔuTGyΔu+fyTΔu+C  (15)

where Gy is Hessian, fy is a linear term and C is constant term that can be omitted for optimization. We assume that Bn matrices are positive definite and so Gy is also positive definite.

One of the most important features of OBC is that it can handle constraints. The constraints for the n-th input may be represented as follows.

i=0 . . . nc−1:

umin(n)≦un(t+i)≦umax(n)—simple bounds

Δumin(n)≦Δun(t+i)≦Δumax(n)—rate of change constraints  (16)

In a compact form, the constraints may be represented as follows.

Δumax=[Δumax(1), . . . ,Δumax(nu)]T 

Δumin=[Δumin(1), . . . ,Δumin(nu)]T 

IcΔumin≦Δu≦IcΔumax 

umax=[umax(1), . . . ,umax(nu)]T 

umin=[umin(1), . . . ,umin(nu)]T 

umin≦u≦umax 

umin≦ScΔu+Icu0≦umax 

Ic(umin−u0)≦ScΔu≦Ic(umax−u0)  (17)

In some cases, controlled variable (i.e., output) may lie within a specific range (i.e., between ymin and ymax). This formulation may lead to more robust and less aggressive control actions but may also results in a more complex optimization calculation. However, if the optimization calculation has hard constraints on outputs, then an infeasible control trajectory may be found. Accordingly, soft constraints with slack variables may be used. However, in order to not to dramatically increase number of decision variables or number of complex constraints, the optimization calculation may be simplified by only adding one additional variable with simple bounds per constrained output. This additional variable may be interpreted as an optimized target that must lie within the specific output range (i.e., between ymin and ymax). For example, output target trajectory yt may be defined by an additional decision variable z and the constrained outputs may be defined by nz with indices k1 . . . knz. Accordingly, objective function and constraints may be defined as follows.




  
    
      
        
          
            
              
                
                  
                    J
                    z
                  
                  ⁡
                  
                    (
                    
                      
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        u
                      
                      ,
                      z
                    
                    )
                  
                
                =
                
                ⁢
                
                  
                    ∑
                    
                      i
                      =
                      1
                    
                    
                      n
                      z
                    
                  
                  ⁢
                  
                    
                      
                        (
                        
                          
                            y
                            
                              k
                              i
                            
                          
                          -
                          
                            1
                            ⁢
                            
                              z
                              i
                            
                          
                        
                        )
                      
                      T
                    
                    ⁢
                    
                      
                        M
                        i
                      
                      ⁡
                      
                        (
                        
                          
                            y
                            
                              k
                              i
                            
                          
                          -
                          
                            1
                            ⁢
                            
                              z
                              i
                            
                          
                        
                        )
                      
                    
                  
                
              
            
          
          
            
              
                =
                
                ⁢
                
                  
                    
                      
                        [
                        
                          
                            
                              
                                Δ
                                ⁢
                                
                                  
                                
                                ⁢
                                u
                              
                            
                          
                          
                            
                              z
                            
                          
                        
                        ]
                      
                      T
                    
                    ⁢
                    
                      
                        G
                        z
                      
                      ⁡
                      
                        [
                        
                          
                            
                              
                                Δ
                                ⁢
                                
                                  
                                
                                ⁢
                                u
                              
                            
                          
                          
                            
                              z
                            
                          
                        
                        ]
                      
                    
                  
                  +
                  
                    
                      f
                      z
                      T
                    
                    ⁡
                    
                      [
                      
                        
                          
                            
                              Δ
                              ⁢
                              
                                
                              
                              ⁢
                              u
                            
                          
                        
                        
                          
                            z
                          
                        
                      
                      ]
                    
                  
                  +
                  C
                
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            y
            min
          
          ≤
          z
          ≤
          
            y
            max
          
        
        ⁢
        
          

        
        ⁢
        
          
            1
            =
            
              
                [
                
                  1
                  ,
                  1
                  ,
                  
                    ...
                    ⁢
                    
                      
                    
                    ⁢
                    1
                  
                
                ]
              
              T
            
          
          ,
          
            

          
          ⁢
          
            z
            =
            
              
                [
                
                  
                    z
                    1
                  
                  ,
                  
                    z
                    2
                  
                  ,
                  
                    ...
                    ⁢
                    
                      
                    
                    ⁢
                    
                      z
                      
                        n
                        z
                      
                    
                  
                
                ]
              
              T
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              y
              max
            
            =
            
              
                [
                
                  
                    
                      y
                      max
                    
                    ⁡
                    
                      (
                      1
                      )
                    
                  
                  ,
                  ...
                  ⁢
                  
                    
                  
                  ,
                  
                    
                      y
                      max
                    
                    ⁡
                    
                      (
                      
                        n
                        z
                      
                      )
                    
                  
                
                ]
              
              T
            
          
          ,
          
            

          
          ⁢
          
            
              y
              min
            
            =
            
              
                [
                
                  
                    
                      y
                      min
                    
                    ⁡
                    
                      (
                      1
                      )
                    
                  
                  ,
                  ...
                  ⁢
                  
                    
                  
                  ,
                  
                    
                      y
                      min
                    
                    ⁡
                    
                      (
                      
                        n
                        z
                      
                      )
                    
                  
                
                ]
              
              T
            
          
        
      
    
    
      
        (
        18
        )
      
    
  




Furthermore, because overall objective function J is then sum J=Jy+Jz the optimization calculation may be as follows.





  
    
      
        
          
            
              min
              
                
                  Δ
                  ⁢
                  
                    
                  
                  ⁢
                  u
                
                ,
                z
              
            
            ⁢
            
              J
              ⁡
              
                (
                
                  
                    Δ
                    ⁢
                    
                      
                    
                    ⁢
                    u
                  
                  ,
                  z
                
                )
              
            
          
          =
          
            
              
                
                  [
                  
                    
                      
                        
                          Δ
                          ⁢
                          
                            
                          
                          ⁢
                          u
                        
                      
                    
                    
                      
                        z
                      
                    
                  
                  ]
                
                T
              
              ⁢
              
                G
                ⁡
                
                  [
                  
                    
                      
                        
                          Δ
                          ⁢
                          
                            
                          
                          ⁢
                          u
                        
                      
                    
                    
                      
                        z
                      
                    
                  
                  ]
                
              
            
            +
            
              
                f
                T
              
              ⁡
              
                [
                
                  
                    
                      
                        Δ
                        ⁢
                        
                          
                        
                        ⁢
                        u
                      
                    
                  
                  
                    
                      z
                    
                  
                
                ]
              
            
            +
            C
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              I
              c
            
            ⁢
            Δ
            ⁢
            
              
            
            ⁢
            
              u
              min
            
          
          ≤
          
            Δ
            ⁢
            
              
            
            ⁢
            u
          
          ≤
          
            
              I
              c
            
            ⁢
            Δ
            ⁢
            
              
            
            ⁢
            
              u
              max
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              I
              c
            
            (
            
              
            
            ⁢
            
              
                u
                min
              
              -
              
                u
                0
              
            
            )
          
          ≤
          
            
              S
              c
            
            ⁢
            Δ
            ⁢
            
              
            
            ⁢
            u
          
          ≤
          
            
              I
              c
            
            ⁢
            
              
            
            ⁢
            
              (
              
                
                  u
                  max
                
                -
                
                  u
                  0
                
              
              )
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            z
            min
          
          ≤
          z
          ≤
          
            z
            max
          
        
      
    
    
      
        (
        19
        )
      
    
  




Using the transformation Δu=Sc−1ur in equation (7), the optimization problem based on relative inputs (ur) is as follows.





  
    
      
        
          
            
              min
              
                u
                ,
                z
              
            
            ⁢
            
              
                J
                r
              
              ⁡
              
                (
                
                  
                    u
                    r
                  
                  ,
                  z
                
                )
              
            
          
          =
          
            
              
                
                  [
                  
                    
                      
                        
                          u
                          r
                        
                      
                    
                    
                      
                        z
                      
                    
                  
                  ]
                
                T
              
              ⁢
              
                
                  G
                  r
                
                ⁡
                
                  [
                  
                    
                      
                        
                          u
                          r
                        
                      
                    
                    
                      
                        z
                      
                    
                  
                  ]
                
              
            
            +
            
              
                f
                r
                T
              
              ⁡
              
                [
                
                  
                    
                      
                        u
                        r
                      
                    
                  
                  
                    
                      z
                    
                  
                
                ]
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              I
              c
            
            ⁡
            
              (
              
                
                  u
                  
                    m
                    ⁢
                    
                      
                    
                    ⁢
                    i
                    ⁢
                    
                      
                    
                    ⁢
                    n
                  
                
                -
                
                  u
                  0
                
              
              )
            
          
          ≤
          
            u
            r
          
          ≤
          
            
              I
              c
            
            ⁡
            
              (
              
                
                  u
                  
                    ma
                    ⁢
                    
                      
                    
                    ⁢
                    x
                  
                
                -
                
                  u
                  0
                
              
              )
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              I
              c
            
            ⁢
            Δ
            ⁢
            
              
            
            ⁢
            
              u
              
                m
                ⁢
                
                  
                
                ⁢
                i
                ⁢
                
                  
                
                ⁢
                n
              
            
          
          ≤
          
            
              S
              c
              
                -
                1
              
            
            ⁢
            
              u
              r
            
          
          ≤
          
            
              I
              c
            
            ⁢
            Δ
            ⁢
            
              
            
            ⁢
            
              u
              
                m
                ⁢
                
                  
                
                ⁢
                ax
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            z
            
              m
              ⁢
              
                
              
              ⁢
              i
              ⁢
              
                
              
              ⁢
              n
            
          
          ≤
          z
          ≤
          
            z
            
              ma
              ⁢
              
                
              
              ⁢
              x
            
          
        
      
    
    
      
        (
        20
        )
      
    
  




Accordingly, taking advantage of that fact that feasible search method more efficiently hand simple bound constraints as compared to complex constraints 136 (e.g., a rate of change constraint), depicted in FIG. 13A, the simple bound constraints 138 may be configured to act as a funnel as depicted in FIG. 13B. Thus, the simple bounds may be expressed as follows.




  
    
      
        
          n
          =
          
            1
            ⁢
            
              
            
            ⁢
            ...
            ⁢
            
              
            
            ⁢
            
              n
              u
            
            ⁢
            
              :
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              
                u
                
                  m
                  ⁢
                  
                    
                  
                  ⁢
                  ax
                
                rn
              
              ⁡
              
                (
                i
                )
              
            
            =
            
              min
              ⁡
              
                (
                
                  
                    
                      
                        u
                        
                          ma
                          ⁢
                          
                            
                          
                          ⁢
                          x
                        
                      
                      ⁡
                      
                        (
                        n
                        )
                      
                    
                    -
                    
                      
                        u
                        0
                      
                      ⁡
                      
                        (
                        n
                        )
                      
                    
                  
                  ,
                  
                    
                      i
                      ·
                      Δ
                    
                    ⁢
                    
                      
                    
                    ⁢
                    
                      
                        u
                        
                          ma
                          ⁢
                          
                            
                          
                          ⁢
                          x
                        
                      
                      ⁡
                      
                        (
                        n
                        )
                      
                    
                  
                
                )
              
            
          
          ,
          
            i
            =
            
              1
              ⁢
              
                
              
              ⁢
              ...
              ⁢
              
                
              
              ⁢
              
                n
                c
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              
                u
                
                  m
                  ⁢
                  
                    
                  
                  ⁢
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  n
                
                rn
              
              ⁡
              
                (
                i
                )
              
            
            =
            
              max
              ⁡
              
                (
                
                  
                    
                      
                        u
                        
                          m
                          ⁢
                          
                            
                          
                          ⁢
                          i
                          ⁢
                          
                            
                          
                          ⁢
                          n
                        
                      
                      ⁡
                      
                        (
                        n
                        )
                      
                    
                    -
                    
                      
                        u
                        0
                      
                      ⁡
                      
                        (
                        n
                        )
                      
                    
                  
                  ,
                  
                    
                      
                        -
                        i
                      
                      ·
                      Δ
                    
                    ⁢
                    
                      
                    
                    ⁢
                    
                      
                        u
                        
                          m
                          ⁢
                          
                            
                          
                          ⁢
                          i
                          ⁢
                          
                            
                          
                          ⁢
                          n
                        
                      
                      ⁡
                      
                        (
                        n
                        )
                      
                    
                  
                
                )
              
            
          
          _
        
        ⁢
        
          

        
        ⁢
        
          
            
              u
              
                ma
                ⁢
                
                  
                
                ⁢
                x
              
              rn
            
            =
            
              
                [
                
                  
                    
                      u
                      
                        ma
                        ⁢
                        
                          
                        
                        ⁢
                        x
                      
                      rn
                    
                    ⁡
                    
                      (
                      1
                      )
                    
                  
                  ,
                  ...
                  ⁢
                  
                    
                  
                  ,
                  
                    
                      u
                      
                        ma
                        ⁢
                        
                          
                        
                        ⁢
                        x
                      
                      rn
                    
                    ⁡
                    
                      (
                      
                        n
                        c
                      
                      )
                    
                  
                
                ]
              
              T
            
          
          ,
          
            

          
          ⁢
          
            
              u
              
                m
                ⁢
                
                  
                
                ⁢
                ax
              
              r
            
            =
            
              
                [
                
                  
                    
                      (
                      
                        u
                        
                          ma
                          ⁢
                          
                            
                          
                          ⁢
                          x
                        
                        
                          r
                          ⁢
                          
                            
                          
                          ⁢
                          1
                        
                      
                      )
                    
                    T
                  
                  ,
                  ...
                  ⁢
                  
                    
                  
                  ,
                  
                    
                      (
                      
                        u
                        
                          ma
                          ⁢
                          
                            
                          
                          ⁢
                          x
                        
                        
                          rn
                          u
                        
                      
                      )
                    
                    T
                  
                
                ]
              
              T
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              u
              
                m
                ⁢
                
                  
                
                ⁢
                i
                ⁢
                
                  
                
                ⁢
                n
              
              rn
            
            =
            
              
                [
                
                  
                    
                      u
                      
                        ma
                        ⁢
                        
                          
                        
                        ⁢
                        x
                      
                      rn
                    
                    ⁡
                    
                      (
                      1
                      )
                    
                  
                  ,
                  ...
                  ⁢
                  
                    
                  
                  ,
                  
                    
                      u
                      
                        ma
                        ⁢
                        
                          
                        
                        ⁢
                        x
                      
                      rn
                    
                    ⁡
                    
                      (
                      
                        n
                        c
                      
                      )
                    
                  
                
                ]
              
              T
            
          
          ,
          
            

          
          ⁢
          
            
              u
              
                m
                ⁢
                
                  
                
                ⁢
                i
                ⁢
                
                  
                
                ⁢
                n
              
              r
            
            =
            
              
                [
                
                  
                    
                      (
                      
                        u
                        
                          m
                          ⁢
                          
                            
                          
                          ⁢
                          i
                          ⁢
                          
                            
                          
                          ⁢
                          n
                        
                        
                          r
                          ⁢
                          
                            
                          
                          ⁢
                          1
                        
                      
                      )
                    
                    T
                  
                  ,
                  ...
                  ⁢
                  
                    
                  
                  ,
                  
                    
                      (
                      
                        u
                        
                          m
                          ⁢
                          
                            
                          
                          ⁢
                          i
                          ⁢
                          
                            
                          
                          ⁢
                          n
                        
                        
                          rn
                          u
                        
                      
                      )
                    
                    T
                  
                
                ]
              
              T
            
          
        
      
    
    
      
        (
        21
        )
      
    
  




Thus, the optimization calculation may be expressed as follows.





  
    
      
        
          
            
              min
              
                
                  u
                  r
                
                ,
                z
              
            
            ⁢
            
              
                J
                r
              
              ⁡
              
                (
                
                  
                    u
                    r
                  
                  ,
                  z
                
                )
              
            
          
          =
          
            
              
                
                  [
                  
                    
                      
                        
                          u
                          r
                        
                      
                    
                    
                      
                        z
                      
                    
                  
                  ]
                
                T
              
              ⁢
              
                
                  G
                  r
                
                ⁡
                
                  [
                  
                    
                      
                        
                          u
                          r
                        
                      
                    
                    
                      
                        z
                      
                    
                  
                  ]
                
              
            
            +
            
              
                f
                r
                T
              
              ⁡
              
                [
                
                  
                    
                      
                        u
                        r
                      
                    
                  
                  
                    
                      z
                    
                  
                
                ]
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            u
            
              m
              ⁢
              
                
              
              ⁢
              i
              ⁢
              
                
              
              ⁢
              n
            
            r
          
          ≤
          
            u
            r
          
          ≤
          
            u
            
              m
              ⁢
              
                
              
              ⁢
              ax
            
            r
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              
                I
                c
              
              ⁢
              Δ
              ⁢
              
                
              
              ⁢
              
                u
                
                  m
                  ⁢
                  
                    
                  
                  ⁢
                  i
                  ⁢
                  
                    
                  
                  ⁢
                  n
                
              
            
            ≤
            
              Ru
              r
            
            ≤
            
              
                I
                c
              
              ⁢
              Δ
              ⁢
              
                
              
              ⁢
              
                u
                
                  ma
                  ⁢
                  
                    
                  
                  ⁢
                  x
                
              
            
          
          ,
          
            

          
          ⁢
          
            
              z
              
                m
                ⁢
                
                  
                
                ⁢
                i
                ⁢
                
                  
                
                ⁢
                n
              
            
            ≤
            z
            ≤
            
              z
              
                ma
                ⁢
                
                  
                
                ⁢
                x
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            R
            =
            
              [
              
                
                  
                    
                      R
                      u
                    
                  
                  
                    0
                  
                  
                    ...
                  
                  
                    0
                  
                
                
                  
                    0
                  
                  
                    
                      R
                      u
                    
                  
                  
                    
                      
                    
                  
                  
                    0
                  
                
                
                  
                    ⋮
                  
                  
                    
                      
                    
                  
                  
                    ⋱
                  
                  
                    
                      
                    
                  
                
                
                  
                    0
                  
                  
                    0
                  
                  
                    
                      
                    
                  
                  
                    
                      R
                      u
                    
                  
                
              
              ]
            
          
          ,
          
            
              R
              u
            
            =
            
              [
              
                
                  
                    
                      -
                      1
                    
                  
                  
                    1
                  
                  
                    0
                  
                  
                    
                      
                    
                  
                  
                    0
                  
                
                
                  
                    0
                  
                  
                    
                      -
                      1
                    
                  
                  
                    1
                  
                  
                    
                      
                    
                  
                  
                    0
                  
                
                
                  
                    
                      
                    
                  
                  
                    
                      
                    
                  
                  
                    
                      
                    
                  
                  
                    ⋱
                  
                  
                    ⋮
                  
                
                
                  
                    0
                  
                  
                    0
                  
                  
                    ...
                  
                  
                    
                      -
                      1
                    
                  
                  
                    1
                  
                
              
              ]
            
          
          ,
        
      
    
    
      
        (
        22
        )
      
    
  




Furthermore, using a common variable x=[urT, zT]T with n elements we get the following resulting optimization problem in a standard form as follows.





  
    
      
        
          
            
              min
              x
            
            ⁢
            
              
                J
                r
              
              ⁡
              
                (
                x
                )
              
            
          
          =
          
            
              
                x
                T
              
              ⁢
              
                G
                r
              
              ⁢
              x
            
            +
            
              
                f
                r
                T
              
              ⁢
              x
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            x
            
              m
              ⁢
              
                
              
              ⁢
              i
              ⁢
              
                
              
              ⁢
              n
            
          
          ≤
          x
          ≤
          
            x
            
              m
              ⁢
              
                
              
              ⁢
              ax
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            Δ
            ⁢
            
              
            
            ⁢
            
              x
              
                m
                ⁢
                
                  
                
                ⁢
                i
                ⁢
                
                  
                
                ⁢
                n
              
            
          
          ≤
          Rx
          ≤
          
            Δ
            ⁢
            
              
            
            ⁢
            
              x
              
                ma
                ⁢
                
                  
                
                ⁢
                x
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            R
            =
            
              [
              
                
                  
                    
                      R
                      u
                    
                  
                  
                    0
                  
                  
                    ...
                  
                  
                    0
                  
                
                
                  
                    0
                  
                  
                    
                      R
                      u
                    
                  
                  
                    
                      
                    
                  
                  
                    0
                  
                
                
                  
                    ⋮
                  
                  
                    
                      
                    
                  
                  
                    ⋱
                  
                  
                    
                      
                    
                  
                
                
                  
                    0
                  
                  
                    0
                  
                  
                    
                      
                    
                  
                  
                    
                      R
                      u
                    
                  
                
              
              ]
            
          
          ,
          
            R
            ⁢
            
              :
            
            ⁢
            
              
                n
                u
              
              ⁡
              
                (
                
                  N
                  -
                  1
                
                )
              
            
            ×
            n
          
          ,
          
            

          
          ⁢
          
            
              R
              u
            
            =
            
              [
              
                
                  
                    
                      -
                      1
                    
                  
                  
                    1
                  
                  
                    0
                  
                  
                    
                      
                    
                  
                  
                    0
                  
                  
                    ...
                  
                  
                    0
                  
                
                
                  
                    0
                  
                  
                    
                      -
                      1
                    
                  
                  
                    1
                  
                  
                    
                      
                    
                  
                  
                    0
                  
                  
                    
                      
                    
                  
                  
                    0
                  
                
                
                  
                    
                      
                    
                  
                  
                    
                      
                    
                  
                  
                    
                      
                    
                  
                  
                    ⋱
                  
                  
                    ⋮
                  
                  
                    
                      
                    
                  
                  
                    
                      
                    
                  
                
                
                  
                    0
                  
                  
                    0
                  
                  
                    ...
                  
                  
                    
                      -
                      1
                    
                  
                  
                    1
                  
                  
                    
                      
                    
                  
                  
                    0
                  
                
              
              ]
            
          
          ,
          
            
              R
              u
            
            ⁢
            
              :
            
            ⁢
            
              (
              
                N
                -
                1
              
              )
            
            ×
            n
          
        
        ⁢
        
          

        
        ⁢
        
          n
          =
          
            
              
                n
                u
              
              ⁢
              N
            
            +
            
              n
              z
            
          
        
      
    
    
      
        (
        23
        )
      
    
  




where

n—number of decision variables (length of x)
nu—number of inputs (manipulated variables)
N—number of control moves (blocks) per control input
nz—number of constrained outputs (controlled variables)
R—delta constraints
It should be notes that the constraints include both a lower and upper bound (bl≦CTx≦bu). Accordingly the constraints may be expressed as follows.




  
    
      
        
          
            
              
                
                  
                    x
                    min
                  
                  ≤
                  x
                  ≤
                  
                    x
                    max
                  
                
              
            
            
              
                
                  
                    Δ
                    ⁢
                    
                      
                    
                    ⁢
                    
                      x
                      min
                    
                  
                  ≤
                  Rx
                  ≤
                  
                    Δ
                    ⁢
                    
                      
                    
                    ⁢
                    
                      x
                      max
                    
                  
                
              
            
          
          ⇔
          
            bl
            ≤
            
              
                C
                T
              
              ⁢
              x
            
            ≤
            bu
          
          ⇔
          
            
              bl
              ⁡
              
                (
                i
                )
              
            
            ≤
            
              
                c
                i
                T
              
              ⁢
              x
            
            ≤
            
              bu
              ⁡
              
                (
                i
                )
              
            
          
        
        ,
        
          

        
        ⁢
        
          
        
        ⁢
        
          i
          =
          
            1
            ⁢
            
              
            
            ⁢
            ...
            ⁢
            
              
            
            ⁢
            m
          
        
      
    
    
      
        (
        24
        )
      
    
  




However, the sign of the dual variables (u) corresponding to constraints with active upper bounds may be changed. As used herein, a dual variable may be a Laplace multiplier. The Lagrange condition for optimum is then that all dual variables are nonnegative or equivalently dual variables corresponding to active lower bounds are nonnegative and dual variables corresponding to active upper bounds are non-positive. Furthermore, sets are defined as follows.

K={1,2, . . . m}—set of all constraints
A⊂K—a subset of constraints
|A|—number of constraints in A
Accordingly, the active set is a subset A⊂K which includes the constraints that are satisfied at the current point (x). In other words, for all i∈A either ciTx=bl(i) or ciTx=bu(i). In addition, a set of active normal vectors may be defined as NA={ci; i∈ A} and the active matrix as N=[n1, . . . nq] composed of all active normal vectors nk=Cik ∈ NA·A unique correspondence may be found between indices k and ik given by an index table IA: ik=IA(k). At the current point the following equality may exist where b is composed of the corresponding components of bl and bu.

NTx=b  (25)

Furthermore, To recognize if the active constraint corresponds to an upper or lower bound we define a vector of flags sfA as follows.





  
    
      
        
          
            sf
            A
          
          ⁡
          
            (
            k
            )
          
        
        =
        
          {
          
            
              
                
                  
                    
                      -
                      1
                    
                  
                  
                    
                      
                        if
                        ⁢
                        
                          
                        
                        ⁢
                        
                          n
                          k
                          T
                        
                        ⁢
                        x
                      
                      =
                      
                        bl
                        ⁡
                        
                          (
                          
                            
                              I
                              A
                            
                            ⁡
                            
                              (
                              k
                              )
                            
                          
                          )
                        
                      
                    
                  
                
                
                  
                    0
                  
                  
                    otherwise
                  
                
              
              ⁢
              
                

              
              ⁢
              k
            
            =
            
              1
              ⁢
              
                
              
              ⁢
              ...
              ⁢
              
                
              
              ⁢
              q
            
          
        
      
    
    
      
        (
        26
        )
      
    
  




Next, the efficiency of the search method utilized in the dynamic optimization 112 may be improved. As described above, one optimization search method that may be utilized is the primal active set solver method. Generally, a primal active set solver method starts from a feasible starting point; however, this may be computationally complex. Accordingly, by exploiting the structure of the optimization calculation, it may be beneficial to simplify finding a feasible starting point.
For example, a good candidate for a feasible starting candidate may be an unconstrained optimum as follows.

xu=−G−1f=−U−TU−1f  (27)

Next, the bounds for xu may be clipped to satisfy the simple bounds as follows.





  
    
      
        
          
            x
            s
            
            
              
              ‘
          
          ⁡
          
            (
            i
            )
          
        
        =
        
          {
          
            
              
                
                  
                    
                      
                        x
                        
                          ma
                          ⁢
                          
                            
                          
                          ⁢
                          x
                        
                      
                      ⁡
                      
                        (
                        i
                        )
                      
                    
                  
                  
                    
                      
                        if
                        ⁢
                        
                          
                        
                        ⁢
                        
                          
                            x
                            u
                          
                          ⁡
                          
                            (
                            i
                            )
                          
                        
                      
                      >
                      
                        
                          x
                          
                            ma
                            ⁢
                            
                              
                            
                            ⁢
                            x
                          
                        
                        ⁡
                        
                          (
                          i
                          )
                        
                      
                    
                  
                
                
                  
                    
                      
                        x
                        
                          m
                          ⁢
                          
                            
                          
                          ⁢
                          i
                          ⁢
                          
                            
                          
                          ⁢
                          n
                        
                      
                      ⁡
                      
                        (
                        i
                        )
                      
                    
                  
                  
                    
                      
                        if
                        ⁢
                        
                          
                        
                        ⁢
                        
                          
                            x
                            u
                          
                          ⁡
                          
                            (
                            I
                            )
                          
                        
                      
                      <
                      
                        
                          x
                          
                            m
                            ⁢
                            
                              
                            
                            ⁢
                            i
                            ⁢
                            
                              
                            
                            ⁢
                            n
                          
                        
                        ⁡
                        
                          (
                          i
                          )
                        
                      
                    
                  
                
                
                  
                    
                      
                        x
                        u
                      
                      ⁡
                      
                        (
                        i
                        )
                      
                    
                  
                  
                    otherwise
                  
                
              
              ⁢
              
                

              
              ⁢
              i
            
            =
            
              1
              ⁢
              
                
              
              ⁢
              ...
              ⁢
              
                
              
              ⁢
              n
            
          
        
      
    
    
      
        (
        28
        )
      
    
  




Finally, xu may be clipped to satisfy delta constraints as follows.





  
    
      
        
          
            
          
          ‘
        
        ⁢
        
          
            
              x
              cu
            
            ⁡
            
              (
              i
              )
            
          
          =
          
            {
            
              
                
                  
                    
                      
                        
                          x
                          s
                        
                        ⁡
                        
                          (
                          1
                          )
                        
                      
                    
                    
                      
                        
                          if
                          ⁢
                          
                            
                          
                          ⁢
                          i
                        
                        =
                        1
                      
                    
                  
                  
                    
                      
                        
                          
                            x
                            cu
                          
                          ⁡
                          
                            (
                            
                              i
                              -
                              1
                            
                            )
                          
                        
                        +
                        
                          Δ
                          ⁢
                          
                            
                          
                          ⁢
                          
                            
                              x
                              
                                ma
                                ⁢
                                
                                  
                                
                                ⁢
                                x
                              
                            
                            ⁡
                            
                              (
                              i
                              )
                            
                          
                        
                      
                    
                    
                      
                        
                          if
                          ⁢
                          
                            
                          
                          ⁢
                          
                            
                              x
                              s
                            
                            ⁡
                            
                              (
                              i
                              )
                            
                          
                        
                        >
                        
                          
                            
                              x
                              cu
                            
                            ⁡
                            
                              (
                              
                                i
                                -
                                1
                              
                              )
                            
                          
                          +
                          
                            Δ
                            ⁢
                            
                              
                            
                            ⁢
                            
                              
                                x
                                
                                  ma
                                  ⁢
                                  
                                    
                                  
                                  ⁢
                                  x
                                
                              
                              ⁡
                              
                                (
                                i
                                )
                              
                            
                          
                        
                      
                    
                  
                  
                    
                      
                        
                          
                            x
                            cu
                          
                          ⁡
                          
                            (
                            
                              i
                              -
                              1
                            
                            )
                          
                        
                        -
                        
                          Δ
                          ⁢
                          
                            
                          
                          ⁢
                          
                            
                              x
                              
                                m
                                ⁢
                                
                                  
                                
                                ⁢
                                i
                                ⁢
                                
                                  
                                
                                ⁢
                                n
                              
                            
                            ⁡
                            
                              (
                              i
                              )
                            
                          
                        
                      
                    
                    
                      
                        
                          if
                          ⁢
                          
                            
                          
                          ⁢
                          
                            
                              x
                              s
                            
                            ⁡
                            
                              (
                              i
                              )
                            
                          
                        
                        <
                        
                          
                            
                              x
                              cu
                            
                            ⁡
                            
                              (
                              
                                i
                                -
                                1
                              
                              )
                            
                          
                          -
                          
                            Δ
                            ⁢
                            
                              
                            
                            ⁢
                            
                              
                                x
                                
                                  m
                                  ⁢
                                  
                                    
                                  
                                  ⁢
                                  i
                                  ⁢
                                  
                                    
                                  
                                  ⁢
                                  n
                                
                              
                              ⁡
                              
                                (
                                i
                                )
                              
                            
                          
                        
                      
                    
                  
                  
                    
                      
                        
                          x
                          s
                        
                        ⁡
                        
                          (
                          i
                          )
                        
                      
                    
                    
                      otherwise
                    
                  
                
                ⁢
                
                  

                
                ⁢
                
                  
                
                ⁢
                i
              
              =
              
                1
                ⁢
                
                  
                
                ⁢
                ...
                ⁢
                
                  
                
                ⁢
                n
              
            
          
        
      
    
    
      
        (
        29
        )
      
    
  




Optionally, further element-wise optimization may be performed. Specifically, when at a point x with gradient g=g(x), element-wise optimization may begin by updating x as follows.

′x(i)=x(i)−g(i)/G(i,i),i=1 . . . n  (30)

Calculating the gradient will be discussed in more detail below. Next, ′x may again be clipped. This procedure may be repeated a predefined number of times. The resulting point may then be used to stabilize the control system 10 as described above.

Similarly, calculating an initial active set may be computationally complex. Accordingly, to simplify the calculation, artificial simple bounds may be used. With a feasible point x0, the active set may be initialized with n simple bounds as follows.

N=In,NA={ek,k=1 . . . n}  (31)

where ek is k-th column of identity matrix
Thus, when x0(k)=xmin(k) the k-th constraint is k-th lower bound, when x0(k)=xmax(k) the k-th constraint is k-th upper bound, and when xmin(k)<x0(k)<xmax(k) the k-th constraint corresponds to an artificial bound x0(k)≦x(k)≦x0(k). During the course of the primal active set solver, the artificial bounds may be deleted from the active set regardless of the sign of the corresponding dual variables. Combining the artificial simple bounds with the initial active set, N=Inxq (0≦q≦n). If q=n the full active set is used. If q=0 an empty active set is used. A good tradeoff may be k=[q/2].
Further efficiency enhancements may be made to the primal active set solver method. For example, rotations may be used to simplify an active set (i.e., constraints) matrix A. Specifically, factorization may be used to rotate the active set matrix when a constraint is added or deleted from active set. The described stable implementation is based on a modified Cholesky factorization of the Hessian matrix G where U is an upper triangular matrix.

G=UUT  (32)

Thus, the modified Cholesky factorization may be computed using a standard Cholesky factorization and a permutation matrix P as follows.





  
    
      
        
          
            PGP
            T
          
          =
          
            
              L
              2
            
            ⁢
            
              L
              2
              T
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            G
            =
            
              UU
              T
            
          
          ,
          
            U
            =
            
              
                P
                T
              
              ⁢
              
                L
                2
              
              ⁢
              P
            
          
          ,
          
            P
            =
            
              [
              
                
                  
                    
                      
                    
                  
                  
                    
                      
                    
                  
                  
                    
                      
                    
                  
                  
                    ⋰
                  
                
                
                  
                    0
                  
                  
                    0
                  
                  
                    1
                  
                  
                    
                      
                    
                  
                
                
                  
                    0
                  
                  
                    1
                  
                  
                    0
                  
                  
                    
                      
                    
                  
                
                
                  
                    1
                  
                  
                    0
                  
                  
                    0
                  
                  
                    
                      
                    
                  
                
              
              ]
            
          
        
      
    
    
      
        (
        33
        )
      
    
  




As described in equation (33) the Hessian matrix is first permuted. Then the standard Cholesky factorization is calculated. Finally, the triangular matrix is permuted to get matrix U. Accordingly the following factorization of the matrix U−1N+, where T+ is an upper triangular matrix, may be used.





  
    
      
        
          
            
              
                (
                
                  M
                  +
                
                )
              
              T
            
            ⁢
            
              U
              
                -
                1
              
            
            ⁢
            
              N
              +
            
          
          =
          
            [
            
              
                
                  
                    T
                    +
                  
                
              
              
                
                  0
                
              
            
            ]
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              
                (
                
                  M
                  +
                
                )
              
              T
            
            ⁢
            
              M
              +
            
          
          =
          
            D
            
              -
              1
            
          
        
        ⁢
        
          

        
        ⁢
        
          D
          =
          
            
              diag
              ⁡
              
                (
                
                  
                    d
                    1
                  
                  ,
                  
                    d
                    2
                  
                  ,
                  
                    ...
                    ⁢
                    
                      
                    
                    ⁢
                    
                      d
                      n
                    
                  
                
                )
              
            
            =
            
              
                [
                
                  
                    
                      
                        D
                        1
                      
                    
                    
                      0
                    
                  
                  
                    
                      0
                    
                    
                      
                        D
                        
                          2
                          ⁢
                          
                            
                          
                        
                      
                    
                  
                
                ]
              
              ⁢
              
                
                  
                    
                      
                        }
                        q
                      
                      ⁢
                      
                        
                      
                    
                  
                
                
                  
                    
                      
                        }
                        n
                      
                      -
                      q
                    
                  
                
              
            
          
        
      
    
    
      
        (
        34
        )
      
    
  




Furthermore, the J+ matrix may be calculated by the following equation.





  
    
      
        
          J
          +
        
        =
        
          
            
              U
              
                -
                T
              
            
            ⁢
            
              M
              +
            
          
          =
          
            
              [
              
                
                  
                    
                      
                        L
                        
                          -
                          T
                        
                      
                      ⁢
                      
                        M
                        1
                        +
                      
                    
                  
                  
                    
                      
                        L
                        
                          -
                          T
                        
                      
                      ⁢
                      
                        M
                        2
                        +
                      
                    
                  
                
              
              ]
            
            =
            
              [
              
                
                  
                    
                      
                        
                          J
                          1
                          +
                        
                        }
                      
                      q
                    
                  
                  
                    
                      
                        J
                        2
                        +
                      
                      
                        }
                        
                          n
                          -
                          q
                        
                      
                    
                  
                
              
              ]
            
          
        
      
    
    
      
        (
        35
        )
      
    
  




The matrices J+, T+, D play a key role as they are may be used for the dynamic optimization calculation. The described factorization has advantage of upper triangularity of matrix U−1. Thus when N+ is composed of an initial part of an identity matrix the factorization is readily available.

As described above, plane rotations may be performed when a constraint is added or removed from the active set. For example, constraint p may be removed from the active set because the corresponding dual variable up is negative. Furthermore, the following matrix structure is assumed.

N+=[N1npN2],N=[N1N2],  (36)

Matrix N+ may first be reordered so that normal np is moved to the last column as follows.

Nr+=[N1N2np]  (37)

Thus, the triangularity of the matrix T+ may be affected as follows.





  
    
      
        
          
            
              (
              
                J
                +
              
              )
            
            T
          
          ⁢
          
            N
            r
            +
          
        
        =
        
          
            
              [
              
                
                  
                    
                      T
                      H
                      +
                    
                  
                
                
                  
                    0
                  
                
              
              ]
            
            ⁢
            
              
                
                  
                    
                      }
                      q
                    
                    ⁢
                    
                      
                    
                  
                
              
              
                
                  
                    
                      }
                      n
                    
                    -
                    q
                  
                
              
            
          
          =
          
            
              [
              
                
                  
                    
                      T
                      1
                    
                  
                  
                    S
                  
                  
                    
                      t
                      
                        p
                        ⁢
                        
                          
                        
                        ⁢
                        1
                      
                    
                  
                
                
                  
                    0
                  
                  
                    V
                  
                  
                    
                      t
                      
                        p
                        ⁢
                        
                          
                        
                        ⁢
                        2
                      
                    
                  
                
                
                  
                    0
                  
                  
                    0
                  
                  
                    0
                  
                
              
              ]
            
            ⁢
            
              
                
                  
                    
                      
                        
                          
                            
                              }
                              p
                            
                            -
                            1
                          
                          ⁢
                          
                            
                          
                        
                      
                    
                    
                      
                        
                          
                            }
                            q
                          
                          -
                          p
                          +
                          1
                        
                      
                    
                  
                
              
              
                
                  
                    
                      
                        }
                        n
                      
                      -
                      q
                    
                    ⁢
                    
                      
                    
                  
                
              
            
          
        
      
    
    
      
        (
        38
        )
      
    
  




In order to restore its upper triangularity, a set of plane rotations Q may be applied to upper Hessenberg sub-matrix [V tp2] where γ is scalar.




  
    
      
        
          
            Q
            ⁡
            
              [
              
                
                  
                    V
                  
                  
                    
                      t
                      
                        p
                        ⁢
                        
                          
                        
                        ⁢
                        2
                      
                    
                  
                
              
              ]
            
          
          =
          
            [
            
              
                
                  
                    T
                    2
                  
                
                
                  
                    d
                    1
                  
                
              
              
                
                  0
                
                
                  γ
                
              
            
            ]
          
        
        ,
        
          

        
        ⁢
        
          
            T
            r
            +
          
          =
          
            
              
                [
                
                  
                    
                      I
                    
                    
                      0
                    
                  
                  
                    
                      0
                    
                    
                      Q
                    
                  
                
                ]
              
              ⁢
              
                T
                H
                +
              
            
            =
            
              
                [
                
                  
                    
                      
                        T
                        1
                      
                    
                    
                      S
                    
                    
                      
                        d
                        1
                      
                    
                  
                  
                    
                      0
                    
                    
                      
                        T
                        2
                      
                    
                    
                      
                        
                      
                    
                  
                  
                    
                      0
                    
                    
                      0
                    
                    
                      γ
                    
                  
                
                ]
              
              =
              
                [
                
                  
                    
                      T
                    
                    
                      
                        d
                        1
                      
                    
                  
                  
                    
                      0
                    
                    
                      γ
                    
                  
                
                ]
              
            
          
        
        ,
        
          d
          =
          
            [
            
              
                
                  
                    d
                    1
                  
                
              
              
                
                  γ
                
              
            
            ]
          
        
      
    
    
      
        (
        39
        )
      
    
  




To nullify elements under the main diagonal, the rotations may be applied to matrix rows in the following order: (1,2), (2,3), . . . (q−p, q−p+1). The same set of plane rotations Q may be applied to corresponding columns (p,p+1), . . . (q−1,q) of matrix J+ as follows.





  
    
      
        
          
            J
            +
          
          =
          
            
              [
              
                
                  
                    
                      
                        
                          J
                          1
                          +
                        
                        }
                      
                      q
                    
                  
                  
                    
                      
                        
                          J
                          2
                          +
                        
                        }
                      
                      
                        n
                        -
                        q
                      
                    
                  
                
              
              ]
            
            =
            
              [
              
                
                  
                    
                      
                        
                          J
                          11
                          +
                        
                        }
                      
                      p
                    
                  
                  
                    
                      
                        
                          J
                          12
                          +
                        
                        }
                      
                      
                        q
                        -
                        p
                      
                    
                  
                  
                    
                      
                        
                          J
                          2
                          +
                        
                        }
                      
                      
                        n
                        -
                        q
                      
                    
                  
                
              
              ]
            
          
        
        ⁢
        
          

        
        ⁢
        
          J
          =
          
            
              [
              
                
                  
                    
                      
                        
                          
                            
                              
                                J
                                11
                                +
                              
                            
                            
                              
                                
                                  J
                                  12
                                  +
                                
                                ⁢
                                
                                  Q
                                  T
                                
                              
                            
                          
                        
                        }
                      
                      q
                    
                  
                  
                    
                      
                        
                          J
                          2
                          +
                        
                        }
                      
                      
                        n
                        -
                        q
                      
                    
                  
                
              
              ]
            
            =
            
              [
              
                
                  
                    
                      
                        
                          J
                          1
                        
                        }
                      
                      
                        q
                        -
                        1
                      
                    
                  
                  
                    
                      
                        
                          J
                          2
                        
                        }
                      
                      
                        n
                        -
                        q
                        +
                        1
                      
                    
                  
                
              
              ]
            
          
        
      
    
    
      
        (
        40
        )
      
    
  




Furthermore, utilizing the dual variable up corresponding to active constraint np, may facilitate finding the optimum solution as follows.

z=−J(:,q+1)D(q+1,q+1)γup  (41)

As used herein, z refers to a step toward the optimum solution in a primal space. In addition, the number constraints in the active set may be decremented as follows.

q=q−1  (42)

Then, when a full step may be applied, the factorization for the reduced active set may be immediately available and the following updates may be made.





  
    
      
        
          
            A
            +
          
          =
          A
        
        ,
        
          
            N
            +
          
          =
          N
        
        ,
        
          
            T
            +
          
          =
          
            
              T
              r
              +
            
            ⁡
            
              (
              
                
                  1
                  ⁢
                  
                    :
                  
                  ⁢
                  q
                
                ,
                
                  1
                  ⁢
                  
                    :
                  
                  ⁢
                  q
                
              
              )
            
          
        
        ,
        
          

        
        ⁢
        
          
            J
            +
          
          =
          
            J
            =
            
              [
              
                
                  
                    
                      
                        
                          J
                          1
                          +
                        
                        }
                      
                      q
                    
                  
                  
                    
                      
                        
                          J
                          2
                          +
                        
                        }
                      
                      
                        n
                        -
                        q
                      
                    
                  
                
              
              ]
            
          
        
      
    
    
      
        (
        43
        )
      
    
  




Finally, equation (41) may be updated accordingly.

z=−J+(:,q+1)D(q+1,q+1)T+(q+1,q+1)up  (44)

On the other hand, constraints may also be added to the active set. For example, constraint nk may be added to active set as follows.

A2=AU{k},N2=[N nk],A+=A2U{P},N+=[N2 np]  (45)

To update the matrix Tr+, the last column d is shifted to the right and a new column h is put in its place as follows.





  
    
      
        
          
            
              N
              +
            
            ⁡
            
              [
              
                
                  
                    N
                  
                  
                    
                      n
                      k
                    
                  
                  
                    
                      n
                      p
                    
                  
                
              
              ]
            
          
          ⁢
          
            

          
          ⁢
          
            
              u
              p
            
            =
            
              
                (
                
                  1
                  -
                  t
                
                )
              
              ⁢
              
                u
                p
              
            
          
          ⁢
          
            

          
          ⁢
          
            
              T
              r
              +
            
            =
            
              [
              
                
                  
                    T
                    r
                    +
                  
                  ⁡
                  
                    (
                    
                      
                        :
                      
                      ,
                      
                        1
                        ⁢
                        
                          :
                        
                        ⁢
                        q
                      
                    
                    )
                  
                
                ,
                h
                ,
                d
              
              ]
            
          
          ⁢
          
            

          
          ⁢
          
            
              h
              =
              
                
                  
                    J
                    T
                  
                  ⁢
                  
                    n
                    k
                  
                
                =
                
                  
                    [
                    
                      
                        
                          
                            h
                            1
                          
                        
                      
                      
                        
                          
                            h
                            2
                          
                        
                      
                    
                    ]
                  
                  ⁢
                  
                    
                      
                        
                          
                            }
                            q
                          
                          ⁢
                          
                            
                          
                        
                      
                    
                    
                      
                        
                          
                            }
                            n
                          
                          -
                          q
                        
                      
                    
                  
                
              
            
            ,
            
              

            
            ⁢
            
              d
              =
              
                
                  [
                  
                    
                      
                        
                          d
                          1
                        
                      
                    
                    
                      
                        
                          d
                          2
                        
                      
                    
                  
                  ]
                
                ⁢
                
                  
                    
                      
                        
                          }
                          q
                        
                        ⁢
                        
                          
                        
                      
                    
                  
                  
                    
                      
                        
                          }
                          n
                        
                        -
                        q
                      
                    
                  
                
              
            
            ,
            
              
                d
                2
              
              =
              
                
                  
                    
                      [
                      
                        
                          
                            γ
                          
                          
                            0
                          
                          
                            ...
                          
                          
                            0
                          
                        
                      
                      ]
                    
                    }
                  
                  
                    n
                    -
                    q
                  
                
                ⁢
                
                   
                  T
                
              
            
          
        
        ⁢
        
          
        
      
    
    
      
        (
        46
        )
      
    
  




Similar to removing a constraint, for the new active set, a sequence of rotations Q may be applied to restore the triangularity. Based on the structure of the Tr+, it may be sufficient to nullify all but the first element of the vector h2. Specifically, the rotations may be applied in the planes (n-q, n-q-1), (n-q-1, n-q-2), . . . (2, 1) as follows.




  
    
      
        
          
            h
            2
          
          =
          
            
              
                [
                
                  
                    
                      x
                    
                  
                  
                    
                      x
                    
                  
                  
                    
                      x
                    
                  
                  
                    
                      x
                    
                  
                
                ]
              
              ->
              
                
                  [
                  
                    
                      
                        x
                      
                    
                    
                      
                        x
                      
                    
                    
                      
                        y
                      
                    
                    
                      
                        0
                      
                    
                  
                  ]
                
                ->
                
                  
                    [
                    
                      
                        
                          x
                        
                      
                      
                        
                          z
                        
                      
                      
                        
                          0
                        
                      
                      
                        
                          0
                        
                      
                    
                    ]
                  
                  ->
                  
                    [
                    
                      
                        
                          α
                        
                      
                      
                        
                          0
                        
                      
                      
                        
                          0
                        
                      
                      
                        
                          0
                        
                      
                    
                    ]
                  
                
              
            
            =
            
              
                h
                2
              
              _
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            d
            2
          
          =
          
            
              
                [
                
                  
                    
                      x
                    
                  
                  
                    
                      0
                    
                  
                  
                    
                      0
                    
                  
                  
                    
                      0
                    
                  
                
                ]
              
              ->
              
                
                  [
                  
                    
                      
                        x
                      
                    
                    
                      
                        0
                      
                    
                    
                      
                        0
                      
                    
                    
                      
                        0
                      
                    
                  
                  ]
                
                ->
                
                  
                    [
                    
                      
                        
                          x
                        
                      
                      
                        
                          0
                        
                      
                      
                        
                          0
                        
                      
                      
                        
                          0
                        
                      
                    
                    ]
                  
                  ->
                  
                    [
                    
                      
                        
                          a
                        
                      
                      
                        
                          b
                        
                      
                      
                        
                          0
                        
                      
                      
                        
                          0
                        
                      
                    
                    ]
                  
                
              
            
            =
            
              
                d
                2
              
              _
            
          
        
      
    
    
      
        (
        47
        )
      
    
  




After these rotations applied to Tr+, the resulting triangular matrix is denotes as T+. If fast rotations are applied then also corresponding diagonal elements of matrix D are updated. The same set of rotations may be applied to the columns of matrix J+ as follows.





  
    
      
        
          
            
              
                
                  
                    
                      Qh
                      2
                    
                    =
                    
                      [
                      
                        
                          
                            α
                          
                        
                        
                          
                            0
                          
                        
                      
                      ]
                    
                  
                  }
                
                ⁢
                n
              
              -
              q
            
            =
            
              
                h
                2
              
              _
            
          
          ,
          
            
              Qd
              2
            
            =
            
              
                d
                2
              
              _
            
          
        
        ⁢
        
          

        
        ⁢
        
          J
          =
          
            [
            
              
                
                  
                    
                      J
                      1
                      +
                    
                    
                      }
                      q
                    
                  
                
                
                  
                    
                      
                        J
                        2
                        +
                      
                      ⁢
                      
                        Q
                        T
                      
                    
                    
                      }
                      
                        n
                        -
                        q
                      
                    
                  
                
              
            
            ]
          
        
      
    
    
      
        (
        48
        )
      
    
  




After the above operations, the number of active constraints and notation of matrices may be updated as follows.




  
    
      
        
          q
          =
          
            q
            +
            1
          
        
        ,
        
          
            J
            +
          
          =
          
            J
            =
            
              [
              
                
                  
                    
                      
                        J
                        1
                        +
                      
                      
                        }
                        q
                      
                    
                  
                  
                    
                      
                        J
                        2
                        +
                      
                      
                        }
                        
                          n
                          -
                          q
                        
                      
                    
                  
                
              
              ]
            
          
        
        ,
      
    
    
      
        (
        49
        )
      
    
  




Thus, equation (41) may be updated accordingly.

z=−J+(:,q+1)D(q+1,q+1)T+(q+1,q+1)up  (50)

Further improvements to the efficiency of the OBC 22, and more specifically the dynamic optimization 112, may be made by exploiting the structure of the optimization calculation. For example, computing the maximum step size. One part of calculating the maximum step size that may be computationally complex is evaluating constraints (i.e., computing scalar product nTz). However, this calculation may be reduced by exploiting the special structure of the constraints. For example, constraints with simple bounds and corresponding slack may be evaluated as follows where ej is j-th column of identity matrix I).




  
    
      
        
          
            n
            T
          
          =
          
            
              e
              j
              T
            
            =
            
              
                [
                
                  
                    
                      
                        0
                        ⁢
                        ...0
                      
                    
                    
                      
                        1
                        
                          }
                          j
                        
                      
                    
                    
                      
                        0
                        ⁢
                        ...0
                      
                    
                  
                
                ]
              
              T
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              n
              T
            
            ⁢
            z
          
          =
          
            z
            ⁡
            
              (
              j
              )
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              s
              min
            
            =
            
              
                x
                ⁡
                
                  (
                  j
                  )
                
              
              -
              
                
                  x
                  min
                
                ⁡
                
                  (
                  j
                  )
                
              
            
          
          ,
          
            

          
          ⁢
          
            
              s
              max
            
            =
            
              
                
                  x
                  max
                
                ⁡
                
                  (
                  j
                  )
                
              
              -
              
                x
                ⁡
                
                  (
                  j
                  )
                
              
            
          
        
      
    
    
      
        (
        51
        )
      
    
  




Similarly, delta constraints (R) may be efficiently evaluated as follows.





  
    
      
        
          
        
        ⁢
        
          
            
              n
              T
            
            =
            
              
                Δ
                j
              
              =
              
                
                  [
                  
                    
                      
                        
                          0
                          ⁢
                          ...0
                        
                      
                      
                        
                          
                            -
                            1
                          
                          
                            }
                            
                              j
                              -
                              1
                            
                          
                        
                      
                      
                        
                          1
                          
                            }
                            j
                          
                        
                      
                      
                        
                          0
                          ⁢
                          ...0
                        
                      
                    
                  
                  ]
                
                T
              
            
          
          ⁢
          
            

          
          ⁢
          
            
          
          ⁢
          
            
              
                n
                T
              
              ⁢
              z
            
            =
            
              
                z
                ⁡
                
                  (
                  j
                  )
                
              
              -
              
                z
                ⁡
                
                  (
                  
                    j
                    -
                    1
                  
                  )
                
              
            
          
          ⁢
          
            

          
          ⁢
          
            
              
                s
                min
              
              =
              
                
                  x
                  ⁡
                  
                    (
                    j
                    )
                  
                
                -
                
                  x
                  ⁡
                  
                    (
                    
                      j
                      -
                      1
                    
                    )
                  
                
                -
                
                  Δ
                  ⁢
                  
                    
                  
                  ⁢
                  
                    x
                    min
                  
                
              
            
            ,
            
              
                s
                max
              
              =
              
                
                  Δ
                  ⁢
                  
                    
                  
                  ⁢
                  
                    x
                    max
                  
                
                -
                
                  x
                  ⁡
                  
                    (
                    j
                    )
                  
                
                +
                
                  x
                  ⁡
                  
                    (
                    
                      j
                      -
                      1
                    
                    )
                  
                
              
            
          
        
      
    
    
      
        (
        52
        )
      
    
  




The structure of the optimization calculation may also be exploited to resolve degeneracy. As used herein, degeneracy refers to linearly dependent constraints in the active set. Accordingly, to avoid adding linearly dependent constraint, the step direction may be refined to reduce round-off errors. For example, if a simple bound constraint ek is active then corresponding element of step direction z(k) must be zero. Moreover, if a delta constraint Δk is active then z(k)=z(k−1). Similarly if neighboring delta constraints Δk, Δk+1 are active then z(k+1)=z(k)=z(k−1).
Specifically, a change of delta constraints may be as follows.

Chainij={Δk;i≦k≦j,Δk∈NA,Δi−1∉NA,Δj+1∉NA}  (53)

An example of active constraints corresponding to a chain is below.





  
    
      
        N
        =
        
          [
          
            
              
                
                  -
                  1
                
              
              
                0
              
              
                0
              
              
                0
              
            
            
              
                1
              
              
                
                  -
                  1
                
              
              
                0
              
              
                0
              
            
            
              
                0
              
              
                1
              
              
                
                  -
                  1
                
              
              
                0
              
            
            
              
                0
              
              
                0
              
              
                1
              
              
                0
              
            
          
          ]
        
      
    
    
      
        (
        54
        )
      
    
  




If there is also active simple bound with index inside a chain then the fixed chain may be defined as follows.

FixedChainijr={Δk;Δk∈Chainij,∃r:i−1≦r≦j,er∈NA}  (55)

An example of active constraints corresponding to a fixed chain is below.





  
    
      
        N
        =
        
          [
          
            
              
                
                  -
                  1
                
              
              
                0
              
              
                0
              
              
                0
              
            
            
              
                1
              
              
                
                  -
                  1
                
              
              
                1
              
              
                0
              
            
            
              
                0
              
              
                1
              
              
                0
              
              
                0
              
            
            
              
                0
              
              
                0
              
              
                0
              
              
                0
              
            
          
          ]
        
      
    
    
      
        (
        56
        )
      
    
  




Based on these definitions a refine function (Ref) may be defined as follows.





  
    
      
        
          z
          r
        
        =
        
          
            
              Ref
              ⁡
              
                (
                z
                )
              
            
            :
            
              

            
            ⁢
            
              
                z
                r
              
              ⁡
              
                (
                i
                )
              
            
          
          =
          
            {
            
              
                
                  0
                
                
                  
                    
                      e
                      i
                    
                    ∈
                    
                      N
                      A
                    
                  
                
              
              
                
                  0
                
                
                  
                    
                      Δ
                      i
                    
                    ∈
                    FixedChain
                  
                
              
              
                
                  0
                
                
                  
                    
                      Δ
                      
                        i
                        +
                        1
                      
                    
                    ∈
                    FixedChain
                  
                
              
              
                
                  
                    z
                    ⁡
                    
                      (
                      
                        i
                        -
                        1
                      
                      )
                    
                  
                
                
                  
                    
                      Δ
                      i
                    
                    ∈
                    Chain
                  
                
              
              
                
                  
                    z
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                
                
                  Otherwise
                
              
            
          
        
      
    
    
      
        (
        57
        )
      
    
  




Thus, the Ref function may prevent adding linearly dependent constraints and so resolve degeneracy.

The structure of the optimization calculation may still further be exploited to calculate the dual variables. Based on the structure of the constraints, the dual variables may calculated directly from the definition. As used herein, a dual variable u corresponds to an active constraint n may be denoted as ud(n). If a simple constraint ek is active and neither Δk nor Δk+1 are active then corresponding dual variable is ud(ek)=gk. If a delta constraint Δk is active and neither Δk−1 nor ek−1 are active then we can put ud(Δk)=−gk−1. If a chain of delta constraints Chainij is active then calculate dual variables for delta constraints i . . . j. This may be accomplished through various methods. For example, the dual variables may be calculated using the following equation.




  
    
      
        
          
            
              u
              d
            
            ⁡
            
              (
              
                Δ
                i
              
              )
            
          
          =
          
            -
            
              g
              
                i
                -
                1
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              u
              d
            
            ⁡
            
              (
              
                Δ
                
                  i
                  +
                  1
                
              
              )
            
          
          =
          
            
              
                u
                d
              
              ⁡
              
                (
                
                  Δ
                  i
                
                )
              
            
            -
            
              g
              i
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              u
              d
            
            ⁡
            
              (
              
                Δ
                
                  i
                  +
                  2
                
              
              )
            
          
          =
          
            
              
                u
                d
              
              ⁡
              
                (
                
                  Δ
                  
                    i
                    +
                    1
                  
                
                )
              
            
            -
            
              g
              
                i
                +
                1
              
            
          
        
        ⁢
        
          

        
        ⁢
        ⋮
        ⁢
        
          

        
        ⁢
        
          
            
              u
              d
            
            ⁡
            
              (
              
                Δ
                j
              
              )
            
          
          =
          
            
              
                u
                d
              
              ⁡
              
                (
                
                  Δ
                  
                    j
                    -
                    1
                  
                
                )
              
            
            -
            
              g
              
                j
                -
                1
              
            
          
        
      
    
    
      
        (
        58
        )
      
    
  




Alternatively, the dual variables may be calculated using the following equation.





  
    
      
        
          
            
              u
              d
            
            ⁡
            
              (
              
                Δ
                j
              
              )
            
          
          =
          
            g
            j
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              u
              d
            
            ⁡
            
              (
              
                Δ
                
                  j
                  -
                  1
                
              
              )
            
          
          =
          
            
              
                u
                d
              
              ⁡
              
                (
                
                  Δ
                  j
                
                )
              
            
            +
            
              g
              
                j
                -
                1
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              u
              d
            
            ⁡
            
              (
              
                Δ
                
                  j
                  -
                  2
                
              
              )
            
          
          =
          
            
              
                u
                d
              
              ⁡
              
                (
                
                  Δ
                  
                    j
                    -
                    1
                  
                
                )
              
            
            -
            
              g
              
                j
                -
                2
              
            
          
        
        ⁢
        
          

        
        ⁢
        ⋮
        ⁢
        
          

        
        ⁢
        
          
            
              u
              d
            
            ⁡
            
              (
              
                Δ
                i
              
              )
            
          
          =
          
            
              
                u
                d
              
              ⁡
              
                (
                
                  Δ
                  
                    i
                    +
                    1
                  
                
                )
              
            
            -
            
              g
              i
            
          
        
      
    
    
      
        (
        59
        )
      
    
  




Or, the dual variables calculated in equation (58) and equation (59) may be averaged. Similarly, various methods may be used when a chain of fixed delta constraints FixedChainijr is active. For example, the dual variables may be calculated for delta constraints i . . . r using equation (58). Alternatively, the dual variables may be calculated for delta constraints r+1 . . . j using equation (59). Furthermore, the dual variables may be calculated for er: ud(er)=gr+ud(Δr+1)−ud(Δr).

As seen in equation (58) and equation (59), the dual variable calculation may utilize gradients. Instead of calculating the absolute value of the gradient it may be more efficient to update it in every step as follows.




  
    
      
        
          
            Δ
            ⁢
            
              
            
            ⁢
            g
          
          =
          
            
              G
              ⁢
              
                
              
              ⁢
              Δ
              ⁢
              
                
              
              ⁢
              x
            
            =
            
              
                ∑
                
                  i
                  =
                  1
                
                n
              
              ⁢
              
                
              
              ⁢
              
                
                  G
                  ⁡
                  
                    (
                    
                      
                        :
                      
                      ,
                      i
                    
                    )
                  
                
                ⁢
                Δ
                ⁢
                
                  
                
                ⁢
                
                  x
                  ⁡
                  
                    (
                    i
                    )
                  
                
              
            
          
        
        ,
        
          

        
        ⁢
        
          
            Δ
            ⁢
            
              
            
            ⁢
            x
          
          =
          tz
        
      
    
    
      
        (
        60
        )
      
    
  




It follows from the structure of the constraints that if simple bound ek is active then corresponding element Δx(k)=0. Similarly, if a fixed chain FixedChainijr is active then corresponding elements Δx(k)=0, k=i . . . j. Furthermore, if a Chainij is active then Δx(k)=Δx(i), k=i . . . j. Thus, multiplication operations may be saved as follows.





  
    
      
        
          
            ∑
            
              k
              =
              i
            
            j
          
          ⁢
          
            
          
          ⁢
          
            
              G
              ⁡
              
                (
                
                  
                    :
                  
                  ,
                  k
                
                )
              
            
            ⁢
            Δ
            ⁢
            
              
            
            ⁢
            x
            ⁢
            
              
            
            ⁢
            
              (
              k
              )
            
          
        
        =
        
          Δ
          ⁢
          
            
          
          ⁢
          
            x
            ⁡
            
              (
              i
              )
            
          
          ⁢
          
            
              ∑
              
                k
                =
                i
              
              j
            
            ⁢
            
              
            
            ⁢
            
              G
              ⁡
              
                (
                
                  
                    :
                  
                  ,
                  k
                
                )
              
            
          
        
      
    
    
      
        (
        61
        )
      
    
  




As such, the computation of dual variable may be accomplished with only elements k of the gradient that correspond to a simple bound ek or a chain Chainij or a fixed chain FixedChainijr with i≦k≦j, which may save other operations. A set of indices of gradient may be updated. If a new constraint is added to the active set, then the corresponding absolute element of the gradient g(k) may be calculated and the next steps we just update it through Δg(k).

In case of adding simple bound ek, the vector h is simply k-th column of the matrix JT.




  
    
      
        
          
            J
            T
          
          ⁢
          
            e
            k
          
        
        =
        
          
            
              J
              T
            
            ⁡
            
              (
              
                
                  :
                
                ,
                k
              
              )
            
          
          =
          
            h
            =
            
              
                [
                
                  
                    
                      
                        h
                        1
                      
                    
                  
                  
                    
                      
                        h
                        2
                      
                    
                  
                
                ]
              
              ⁢
              
                
                  
                    
                      }
                      q
                    
                  
                
                
                  
                    
                      
                        }
                        n
                      
                      -
                      q
                    
                  
                
              
            
          
        
      
    
    
      
        (
        62
        )
      
    
  




In case of adding delta constraint Δk, the vector h may simply be the difference of the k-th and (k−1)-th columns of the matrix JT.





  
    
      
        
          
            J
            T
          
          ⁢
          
            Δ
            k
          
        
        =
        
          
            
              
                J
                T
              
              ⁡
              
                (
                
                  
                    :
                  
                  ,
                  k
                
                )
              
            
            -
            
              
                J
                T
              
              ⁡
              
                (
                
                  
                    :
                  
                  ,
                  
                    k
                    -
                    1
                  
                
                )
              
            
          
          =
          
            h
            =
            
              
                [
                
                  
                    
                      
                        h
                        1
                      
                    
                  
                  
                    
                      
                        h
                        2
                      
                    
                  
                
                ]
              
              ⁢
              
                
                  
                    
                      }
                      q
                    
                  
                
                
                  
                    
                      
                        }
                        n
                      
                      -
                      q
                    
                  
                
              
            
          
        
      
    
    
      
        (
        63
        )
      
    
  




The matrix J=U−T is initially lower triangular. For every column J(:,k) of the matrix J an integer number (ok) that corresponds to a number of zeros in the initial part of the vector may be store and maintain. In other words, J(i,k)=0 for i=1 . . . ok. Plane rotation may then be applied to two neighboring columns J(:,k) and J(:,k+1) as follows.




  
    
      
        
          
            [
            
              
                J
                ⁡
                
                  (
                  
                    
                      :
                    
                    ,
                    k
                  
                  )
                
              
              ⁢
              
                
              
              ⁢
              
                J
                ⁡
                
                  (
                  
                    
                      :
                    
                    ,
                    
                      k
                      +
                      1
                    
                  
                  )
                
              
            
            ]
          
          ⁢
          
            Q
            T
          
        
        =
        
          
            
              
                
                  
                    1
                  
                
                
                  
                    ⋮
                  
                
                
                  
                    
                      o
                      k
                    
                  
                
                
                  
                    
                      
                    
                  
                
                
                  
                    
                      
                    
                  
                
              
              ⁡
              
                [
                
                  
                    
                      0
                    
                    
                      0
                    
                  
                  
                    
                      ⋮
                    
                    
                      ⋮
                    
                  
                  
                    
                      0
                    
                    
                      0
                    
                  
                  
                    
                      x
                    
                    
                      0
                    
                  
                  
                    
                      x
                    
                    
                      x
                    
                  
                
                ]
              
            
            ⁢
            
              Q
              T
            
          
          =
          
            [
            
              
                
                  0
                
                
                  0
                
              
              
                
                  ⋮
                
                
                  ⋮
                
              
              
                
                  0
                
                
                  0
                
              
              
                
                  y
                
                
                  y
                
              
              
                
                  y
                
                
                  y
                
              
            
            ]
          
        
      
    
    
      
        (
        64
        )
      
    
  




It should be appreciated that ok+1 . . . n may be rotated. After the rotation, the integer ok+1 may be incremented.

Furthermore, it may also possible to take advantage of the special sparse structure of the matrix J in the procedure of adding constraint. For example, when adding simple bound ek or delta constraint Δk there is good chance, in the early stages of the optimization calculation, that m last elements of the vector h2 are zeros. For each column of the matrix J a variable that stores the number of zeros in the initial part of the column may be defined. When two columns are rotated these numbers are used to calculate an initial index from which to start rotations. Accordingly unnecessary operations may be avoided.
Generally, the above techniques enable deterministic optimization control to be used with plants/process 12 with fast dynamics. More specifically, the OBC 22 is configured to provide a stable feasible control trajectory during each control time, which may include comparing the cost of feasible solutions (i.e., control trajectory) to the cost of previous solutions. Furthermore, techniques are described herein to improve the efficiency of the OBC 22 by simplifying complex calculations, such as dynamic optimization.
While only certain features of the invention have been illustrated and described herein, many modifications and changes will occur to those skilled in the art. It is, therefore, to be understood that the appended claims are intended to cover all such modifications and changes as fall within the true spirit of the invention.

## Claims

1. A control system, comprising:
a controller that, in operation, controls operation an industrial process;
the controller being configured to, in operation, perform the following steps:
determining, using a control system, a first feasible control trajectory comprising a first control action to implement in the process during a first future time step and a second control action to implement in the industrial process during a second future time step after the first future time step;
determining, using the control system, a second feasible control trajectory comprising the second control action by time shifting the first feasible control trajectory from the first future time step to the second future time step;
determining, using the control system, a third feasible control trajectory comprising a third control action to implement in the industrial process during the second future time stamp by performing a first optimization search based at least in part on state of the industrial process and constraints on operation of the industrial process;
determining, using the control system, a first cost associated with implementing the second control action during the second future time step based at least in part on an objective function;
determining, using the control system, a second cost associated with implementing the third control action during the second future time step based at least in part on the objective function; and
controlling, using the control system, the operation of the industrial process by instructing the industrial process to implement the second control action or the third control action based at least in part on the first cost and the second cost.

2. The system of claim 1, wherein the controller is configured to, in operation, perform the following steps:
determining the first feasible control trajectory comprises performing a second optimization search based at least in part on state of the industrial process and constraints on operation of the industrial process during the first time step; and
determining the second feasible control trajectory comprises performing the first optimization search based at least in part on the state of the industrial process and the constraints on operation of the industrial process during the second time.

3. The system of claim 2, wherein the first optimization search-comprises a feasible optimization search, the second optimization search comprises the feasible optimization search, or both.

4. The system of claim 3, wherein the feasible optimization search comprises a primal active set solver.

5. The system of claim 1, wherein the first feasible control trajectory comprises a shifted and padded version of the control trajectory used during the first time step.

6. The system of claim 1, wherein the controller is configured to, in operation, determine the first feasible control trajectory and the second feasible control trajectory during operation of the industrial process.

7. The system of claim 1, wherein determining the second feasible control trajectory comprises:
determining an infeasible control trajectory during an allotted amount of time, wherein the infeasible control trajectory does not satisfy constraints on the operation of the industrial process; and
mapping the infeasible control trajectory to the second feasible control trajectory, wherein the second feasible control trajectory satisfies the constraints on the operation of the industrial process.

8. The system of claim 1, wherein determining the second feasible control trajectory comprises:
performing the first optimization search based at least in part on a non-linear model configured to model operation of the industrial process; and
determining the second feasible control trajectory based at least in part on results from the optimization search to ensure that the second feasible control trajectory satisfies each constraint on the operation of the industrial process.

9. A method of controlling operation of an industrial process, comprising:
determining, using a control system, a first feasible control trajectory comprising a first control action to implement in the industrial process during a first future time step and a second control action to implement in the industrial process during a second future time step after the first future time step;
determining, using the control system, a second feasible control trajectory comprising the second control action by time shifting the first feasible control trajectory from the first future time step to the second future time step;
determining, using the control system, a third feasible control trajectory comprising a third control action to implement in the industrial process during the second future time stamp by performing a first optimization search based at least in part on state of the industrial process and constraints on operation of the industrial process;
determining, using the control system, a first cost associated with implementing the second control action during the second future time step based at least in part on an objective function;
determining, using the control system, a second cost associated with implementing the third control action during the second future time step based at least in part on the objective function; and
controlling, using the control system, the operation of the industrial process by instructing the industrial process to implement the second control action or the third control action based at least in part on the first cost and the second cost.

10. The method of claim 9, wherein determining the first feasible control trajectory comprises performing a second optimization search based at least in part on the state of the industrial process and the constraints on operation of the industrial process during the first future time step.

11. The method of claim 9, wherein performing the first optimization search comprises:
determining a feasible region based at least in part on the constraints on the operation of the industrial process;
determining a cost associated with a plurality of points within the feasible region based at least in part on the objective function; and
selecting one point from the plurality of points based at least in part on associated costs, wherein the one point comprises the third feasible control trajectory.

12. The method of claim 9, wherein:
determining the second feasible control trajectory comprises padding the first feasible control trajectory by adding a fourth control action to be implemented in the industrial process during a third future time step after the second future time step; and
the third feasible control trajectory comprises a fifth control action to be implemented in the industrial process during the third future time step.

13. The method of claim 9, wherein controlling the operation of the industrial process comprises:
instructing the industrial process to implement the second control action when the first cost is less than the second cost; and
instructing the industrial process to implement the third control action when the second cost is less than the first cost.

14. The method of claim 9, wherein performing the first optimization search comprises:
determining a feasible region and an infeasible region based at least in part on the constraints on the operation of the industrial process;
determining a cost associated with a plurality of points within the feasible region and the infeasible region based at least in part on the objective function;
selecting a first point from the plurality of points based at least in part on associated costs, wherein the first point comprises the third feasible control trajectory when within the feasible region; and
mapping the first point to a second point in the feasible region when the first point is within the infeasible region, wherein the second point comprises the third feasible control trajectory.

15. The method of claim 9, wherein:
determining the second feasible control trajectory comprises determining the second feasible trajectory during operation of the industrial process; and
determining the third feasible control trajectory comprises determining the third feasible trajectory during operation of the industrial process.

16. A tangible, non-transitory, computer-readable medium configured to store instructions executable by one or more processors of a control system, wherein the instructions comprise instructions to:
determine, using a control system, a first feasible control trajectory comprising a first control action to implement in the process during a first future time step and a second control action to implement in the industrial process during a second future time step after the first future time step;
determine, using the control system, a second feasible control trajectory comprising the second control action by time shifting the first feasible control trajectory from the first future time step to the second future time step;
determine, using the control system, a third feasible control trajectory comprising a third control action to implement in the industrial process during the second future time stamp by performing a first optimization search based at least in part on state of the industrial process and constraints on operation of the industrial process;
determine, using the control system, a first cost associated with implementing the second control action during the second future time step based at least in part on an objective function;
determine, using the control system, a second cost associated with implementing the third control action during the second future time step based at least in part on the objective function; and
control, using the control system, the operation of the industrial process by instructing the industrial process to implement the second control action or the third control action based at least in part on the first cost and the second cost.

17. The computer-readable medium of claim 16, wherein determining the first feasible control trajectory comprises performing a second optimization search based at least in part on the state of the industrial process and the constraints on operation of the industrial process during the first future time step.

18. The computer-readable medium of claim 16, wherein performing the first optimization search comprises:
determining a feasible region based at least in part on the constraints on the operation of the industrial process;
determining a cost associated with a plurality of points within the feasible region based at least in part on the objective function; and
selecting one point from the plurality of points based at least in part on associated costs, wherein the one point comprises the third feasible control trajectory.

19. The computer-readable medium of claim 16, wherein determining the second feasible control trajectory comprises padding the first feasible control trajectory by adding a fourth control action to be implemented in the industrial process during a third future time step after the second future time step; and
the third feasible control trajectory comprises a fifth control action to be implemented in the industrial process during the third future time step.

20. The computer-readable medium of claim 16, wherein controlling the operation of the industrial process comprises:
instructing the industrial process to implement the second control action when the first cost is less than the second cost; and
instructing the industrial process to implement the third control action when the second cost is less than the first cost.