Standard Linear Constraints

The following table shows the standard linear constraints supported by nonlinear MPC controllers. For each of these constraints, you can specify a single bound that applies across the entire prediction horizon, or you can vary each constraint over the prediction horizon. For more information on setting controller linear constraint properties, see nlmpc.

Custom Constraints

You can specify custom equality and inequality constraints for a nonlinear MPC controller. To configure your nonlinear MPC controller to use custom equality or inequality constraints, set its Optimization.CustomEqConFcn or Optimization.CustomIneqConFcn respectively. To do so, specify the custom functions as one of the following.

Your constraint functions must have one of the following signatures.

This table describes the inputs and outputs of these functions, where:

To use output variable values in your constraint functions, you must first derive them from the state and input arguments using the prediction model output function, as specified in the Model.OutputFcn property of the controller. For example, to compute the output trajectory Y from time k to time k+p, use:

p = data.PredictionHorizon;
for i=1:p+1
    Y(i,:) = myOutputFunction(X(i,:)',U(i,:)',params)';
end

For more information on the prediction model output function, see Specify Prediction Model for Nonlinear MPC.

In general:

You can define custom constraints that apply across the entire prediction horizon. For example, suppose that you want to satisfy the following inequality constraints across the prediction horizon, where u₁ is the first manipulated variable:

To define the constraint values across the prediction horizon, use:

p = data.PredictionHorizon;
U1 = U(1:p,data.MVIndex(1));
X1 = X(2:p+1,1);
X2 = X(2:p+1,2);

cineq = [2*X1.^2 - 3*X2 - 10;
         U1.^2 - 5];

Applying these two constraints across p prediction horizon steps produces a column vector with 2*p inequality constraints. These inequality constraints are satisfied when the corresponding element of cineq is less than or equal to zero.

Alternatively, you can define constraints that apply at specific prediction horizon steps. For example, suppose that you want the states of a third-order plant to be:

To specify these state values as constraints on only the final prediction horizon step, use:

ceq = [X(p+1,1) - 5;
       X(p+1,2) + 3;
       X(p+1,3)];

These equality constraints are satisfied when the corresponding element of ceq is equal to zero.

For relatively simple constraints, you can specify the constraint function using an anonymous function handle. For example, to specify an anonymous function that implements the equality constraints, use:

Optimization.CustomEqConFcn = @(X,U,data) [X(p+1,1) - 5; X(p+1,2) + 3; X(p+1,3)];

Custom Constraint Jacobians

To improve computational efficiency, it is best practice to specify analytical Jacobians for your custom constraint functions. If you do not specify Jacobians, the controller computes the Jacobians using numerical perturbation.

To specify a Jacobian for your equality or inequality constraint functions, set the respective Jacobian.CustomEqConFcn or Jacobian.CustomIneqConFcn property of the controller to one of the following.

Your constraint Jacobian functions must have one of the following signatures.

The input arguments of the constraint Jacobian functions are the same as the inputs of their respective custom constraint functions. This table describes the outputs of the Jacobian functions, where:

To use output variable Jacobians in your constraint Jacobian functions, you must first derive them from the state and input arguments using the Jacobian of the prediction model output function, as specified in the Jacobian.OutputFcn property of the controller. For example, to compute the output variable Jacobians Yjacob from time k to time k+p, use:

p = data.PredictionHorizon;
for i=1:p+1
    Y(i,:) = myOutputFunction(X(i,:)',U(i,:)',params)';
end
for i=1:p+1
    Yjacob(i,:) = myOutputJacobian(X(i,:)',U(i,:)',params)';
end

Since prediction model output functions do not support direct feedthrough from inputs to outputs, the output function Jacobian contains partial derivatives with respect to only the states in X. For more information on the output function Jacobian, see Specify Prediction Model for Nonlinear MPC.

To find the Jacobians, compute the partial derivatives of the constraint functions with respect to the state trajectories, manipulated variable trajectories, and slack variable. For example, suppose that your constraint function is as follows, where u₁ is the first manipulated variable.

To compute the Jacobian with respect to the state trajectories, use:

Nx = data.NumOfStates;
Nc = 2*p;
G = zeros(p,Nx,Nc);
G(1:p,1,1:p) = diag(4*X1);
G(1:p,2,1:p) = diag(-3*ones(p,1));

To compute the Jacobian with respect to the manipulated variable trajectories, use:

Nmv = length(data.MVIndex);
Gmv = zeros(p,Nmv,Nc);
Gmv(1:p,1,p+1:2*p) = diag(2*u(1:p,data.MVIndex(1)));

In this case, the derivative with respect to the slack variable is Ge = zeros(20,1).

Passivity Constraints

You can specify passivity inequality constraints for a general nonlinear MPC controller (multistage MPC controllers do not support passivity constraints). To use passivity constraints, set these properties of your nlmpc object as follows:

When your nonlinear MPC controller is configured to use passivity constraints, at each step the optimization algorithm tries to enforce the inequality constraint:

$$y_p{(x,u)}^T{u}_p(x,u)+{\nu }_y{y}_p{(x,u)}^T{y}_p(x,u)+{\nu }_u{u}_p{(x,u)}^T{u}_p(x,u)\le 0$$.

Here, ν_y is the output passivity index, ν_u is the input passivity index, u_p(x,u) is the passivity input function, and y_p(x,u) is the passivity output function. The variables x and u are the current state and input of the prediction model.

A dynamical system is said to be passive with respect to the input-output pair u_p and y_p if there is a continuously differentiable positive definite function V(x), usually called storage function, such that $$\dot{V}(x)\le u_p{(x,u)}^T{y}_p(x,u)$$. Indeed, you can often find a valid storage function for your plant first, and then derive the passivity input-output function pair from it.

In general, for physical systems, you can use the total energy of the system as a storage function. Similarly to the problem of finding a Lyapunov function, you can look for terms in the system dynamics that represent potential or kinetic energy, and use them to construct a candidate storage function that is positive definite and radially unbounded. For more general nonlinear systems, you may need to use techniques based on sum-of-squares optimization or neural networks.

Assuming that the plant is already passive with respect to the input-output pair u_p and y_p, if the controller is able to enforce the inequality constraint, then (under mild conditions) the resulting closed loop system tends to dissipate energy over time, and therefore has a stable equilibrium. For more information on passivity in the context of linear systems, see About Passivity and Passivity Indices. For examples of enforcing passivity constraints in simulation, see Passivity Enforcement for Control Design (Simulink Control Design).

To improve computational efficiency, you can specify analytical Jacobians for your passivity constraint functions. To do so, specify the Passivity.OutputJacobianFcn and Passivity.InputJacobianFcn properties.

You can specify the passivity functions and their Jacobians as one of the following:

The passivity functions and their Jacobians must accept as first and second input arguments the current state and input of the prediction model, respectively. After the first two input arguments, you can also pass an optional comma separated list of parameters (for example p1,p2,p3) that might be needed by the function you specify.

If any of your functions use optional parameters, you must specify the number of parameters using Model.NumberOfParameters. At run time, in Simulink, you then pass these parameters to the Nonlinear MPC Controller block. In MATLAB, you pass the parameters to a simulation function (such as nlmpcmove, using an nlmpcmoveopt option set object).

The function specified in Passivity.OutputJacobianFcn (if any) must return as a first output argument the Jacobian matrix of the output passivity function with respect to the current state (an N_yp-by-N_x matrix) and as a second output argument the Jacobian matrix of the output passivity function with respect to the manipulated variables (an N_yp by N_mv matrix).

Similarly, the function specified in Passivity.InputJacobianFcn (if any) must return as a first output argument the Jacobian of the input passivity function with respect to the current state (an N_up-by-N_x matrix) and as a second output argument the Jacobian of the input passivity function with respect to the manipulated variables (an N_up by N_mv matrix).

Here, N_x is the number of state variables of the prediction model, N_mv is the number of manipulated variables, N_yp is the number of outputs of the passivity output function, and N_up is the number of outputs of the passivity input function.

For more detail, see the Passivity property of nlmpc. For examples, see Control Quadruple-Tank Using Passivity-Based Nonlinear MPC and Control Robot Manipulator Using Passivity-Based Nonlinear MPC.