Linear MPC and Nonlinear MPC

The core computational engine of Linear MPC is a Quadratic Programming (QP) problem. This is because the cost function is quadratic (e.g., penalizing squared tracking error and control effort) and the dynamic model and constraints are linear. Convex QP problems have a single global optimum and can be solved reliably and efficiently with mature numerical solvers like interior-point methods or active-set methods. This guarantees that a feasible control action is always computed within the required sampling time, a cornerstone of Real-Time Optimization (RTO).

Linear MPC relies on a linear time-invariant (LTI) or linear time-varying state-space model to predict future system behavior. Common forms include:

• Discrete-time state-space: x(k+1) = A x(k) + B u(k)
• Transfer function models converted to state-space.
• Linear approximations of nonlinear systems around an operating point. The use of a linear model is the primary differentiator from Nonlinear MPC (NMPC). It simplifies the prediction equations, making them a linear function of the current state and future control inputs, which directly enables the QP formulation.

A major advantage over classical control is the ability to explicitly and systematically handle state constraints (e.g., position limits, safe temperatures) and input constraints (e.g., actuator saturation, valve limits). These are formulated as linear inequalities within the QP. Strategies include:

• Hard constraints: Must not be violated; the optimizer finds a solution within the feasible region.
• Soft constraints: Implemented with slack variables; they can be slightly violated at a high penalty in the cost function, ensuring the QP problem remains feasible even during large disturbances.

For a theoretically sound controller, Linear MPC designs must ensure closed-loop stability and recursive feasibility. This is often achieved using design techniques like:

• Terminal cost: A quadratic term based on the solution to the Algebraic Riccati Equation (ARE), penalizing the final state in the prediction horizon.
• Terminal constraint: Requiring the predicted state at the end of the horizon to lie within a terminal invariant set. Together, these tools allow the MPC law to be interpreted as a Lyapunov function, guaranteeing that the system state converges to the desired setpoint or region.

Linear MPC operates on the principle of Receding Horizon Control. At each control interval:

1. Measure/estimate the current system state.
2. Solve the QP to compute an optimal sequence of future control inputs over the prediction horizon.
3. Apply only the first control input from this sequence to the physical system.
4. At the next time step, shift the horizon forward, incorporate new measurements, and repeat the optimization. This feedback mechanism provides inherent robustness to model mismatch and disturbances.

Linear MPC requires full knowledge of the system state x(k) for its predictions. Since not all states are directly measured, a state estimator or observer is almost always required. The canonical choice is the Kalman Filter, which provides an optimal estimate for linear systems with Gaussian noise. The estimated state serves as the initial condition for the prediction model in the QP. This combination of estimation and control is sometimes referred to as the separation principle in linear systems.

A Quadratic Programming (QP) problem is a convex optimization problem with a quadratic objective function and linear constraints. It is the core mathematical problem solved at each control step in Linear MPC. The standard form is:

• Minimize: (1/2)xᵀHx + fᵀx
• Subject to: Ax ≤ b, A_eq x = b_eq Where x is the vector of optimization variables (future control inputs). The convexity of QP guarantees a globally optimal solution can be found efficiently with specialized solvers like interior-point methods or active-set methods, enabling reliable real-time control.

A Nonlinear Programming (NLP) problem involves minimizing a nonlinear objective function subject to nonlinear constraints. This is the fundamental optimization problem in Nonlinear MPC (NMPC). Solving NLPs is significantly more complex than QPs because:

• Solutions may be only locally optimal, not globally optimal.
• Convergence is not guaranteed and depends heavily on the initial guess.
• Computational cost is higher and less predictable. Common solution algorithms include Sequential Quadratic Programming (SQP) and Interior-Point Methods, which iteratively approximate the NLP with simpler sub-problems.

Sequential Quadratic Programming (SQP) is a leading iterative algorithm for solving the Nonlinear Programming (NLP) problems in NMPC. At each iteration, it approximates the original problem by a Quadratic Programming (QP) subproblem:

1. The nonlinear cost function is approximated by a quadratic model.
2. Nonlinear constraints are linearized.
3. The resulting QP is solved to find a search direction.
4. A step is taken, and the process repeats until convergence. SQP is favored for its fast local convergence properties. Efficient implementation requires accurate gradient and Hessian information, often obtained via automatic differentiation.

This distinction is the primary differentiator between Linear and Nonlinear MPC.

• Convex Optimization (Linear MPC): The feasible set and the cost function form a convex shape. Any local minimum is a global minimum. This guarantees solution uniqueness and allows for fast, reliable solvers.
• Non-Convex Optimization (Nonlinear MPC): The feasible set or cost function has "hills and valleys." Algorithms can get stuck in local minima that are not the best overall solution. This introduces uncertainty in solution quality and requires careful initialization (e.g., warm-starting) and potentially global optimization techniques for complex problems.

System identification is the process of building the dynamic model used inside the MPC predictor from experimental input-output data. The model's accuracy is critical for prediction quality.

• For Linear MPC: Techniques like subspace identification or prediction error methods are used to fit a linear state-space model (e.g., x_{k+1} = Ax_k + Bu_k).
• For Nonlinear MPC: Methods are more complex, including:
  • Nonlinear ARX models or Hammerstein-Wiener models.
  • Neural network or Gaussian process models.
  • First-principles (white-box) models derived from physics. The choice between linear and nonlinear MPC often hinges on whether a sufficiently accurate linear model can be identified.

The Real-Time Iteration (RTI) scheme is a computational strategy to make Nonlinear MPC feasible for real-time applications with fast sampling rates (e.g., robotics, automotive). Instead of solving the NLP to full convergence at each step, it performs only one SQP iteration per control interval.

• Preparation Phase: Between control steps, linearizations and matrix factorizations are computed using the current state estimate.
• Feedback Phase: Upon receiving a new measurement, the pre-prepared QP is solved rapidly to compute the control input. This scheme trades off a small amount of optimality for a drastic reduction in computation time, enabling NMPC on embedded hardware.