Cost Function (Objective Function)

This is the primary term that penalizes deviation from a desired trajectory or setpoint. It is typically formulated as a quadratic function of the difference between the predicted system states or outputs and their target values over the prediction horizon.

• Mathematical Form: Often expressed as (x - x_ref)^T * Q * (x - x_ref), where Q is a positive semi-definite weighting matrix.
• Purpose: Drives the system to follow the commanded path as closely as possible.
• Design Choice: The matrix Q allows the engineer to prioritize which states (e.g., position vs. velocity) are most critical to track accurately.

This term penalizes the magnitude of the control inputs (e.g., motor torque, steering angle) applied to the system. Minimizing control effort reduces energy consumption, actuator wear, and aggressive, potentially destabilizing actions.

• Mathematical Form: Typically u^T * R * u, where R is a positive definite weighting matrix.
• Purpose: Promotes smooth, efficient control actions and prevents actuator saturation.
• Trade-off: Tuned against the tracking error term. A high R weight results in slower, more conservative control, while a low weight allows for more aggressive tracking.

An additional cost term evaluated specifically at the final state of the prediction horizon. It is a crucial theoretical tool for ensuring closed-loop stability.

• Mathematical Form: Often x_N^T * P * x_N, where P is computed as the solution to an Algebraic Riccati Equation (ARE) related to the infinite-horizon Linear Quadratic Regulator (LQR).
• Purpose: Approximates the cost-to-go beyond the finite prediction horizon, encouraging the predicted terminal state to be near a desirable equilibrium.
• Stability: When combined with a terminal constraint, it can provide formal guarantees of asymptotic stability for the MPC law.

A mechanism to handle soft constraints. When hard constraints (e.g., position limits) might make the optimization problem infeasible, slack variables are introduced and penalized in the cost function.

• How it works: A slack variable ε absorbs constraint violations. The cost function includes a term like ρ * ε^2, where ρ is a large, tunable penalty weight.
• Purpose: Ensures the online optimizer always has a feasible solution, improving controller robustness to unexpected disturbances or infeasible commands.
• Use Case: Essential for practical deployment where temporary, minor constraint breaches are preferable to controller failure.

Penalizes large changes in control inputs between consecutive time steps. This term directly influences the smoothness of the actuation signal.

• Mathematical Form: Δu^T * S * Δu, where Δu = u_k - u_{k-1} and S is a weighting matrix.
• Purpose: Reduces mechanical stress on actuators, improves passenger comfort in vehicles, and filters out high-frequency noise from the control signal.
• Practical Impact: A well-tuned rate penalty prevents 'chattering'—rapid, oscillatory control actions that waste energy and cause wear.

In Economic MPC (EMPC), the cost function moves beyond traditional regulation to directly encode a process economics or utility goal.

• Examples: Minimizing energy consumption in a building's HVAC system, maximizing throughput in a chemical reactor, or minimizing fuel use in a vehicle.
• Key Difference: The cost function is not necessarily positive definite around a setpoint. The controller seeks a dynamically optimal operating point, which may involve transient excursions to improve long-term economic performance.
• Application: Common in process industries and energy systems where operational profit, not just setpoint tracking, is the primary goal.

The most common form in Linear MPC, penalizing the squared deviation of predicted states and inputs from their desired references. It leads to a convex Quadratic Programming (QP) problem.

• Mathematical Form: ( J = \sum_{k=0}^{N-1} (x_k - x_{ref})^T Q (x_k - x_{ref}) + (u_k - u_{ref})^T R (u_k - u_{ref}) + (x_N - x_{ref})^T P (x_N - x_{ref}) )
• Weights: ( Q ), ( R ), and ( P ) are positive (semi-)definite weighting matrices that tune the trade-off between state error and control effort.
• Example: In autonomous vehicle path following, ( x ) represents lateral deviation and heading error, weighted by ( Q ), while ( u ) represents steering angle, weighted by ( R ) to ensure smooth driving.

Directly encodes operational economics, such as profit maximization or energy cost minimization, rather than traditional reference tracking. This is central to Economic MPC.

• Objective: Minimize a stage cost ( \ell(x_k, u_k) ) that represents instantaneous economic loss (e.g., $/hr).
• Key Challenge: Stability is not inherent and must be enforced via additional constraints or a terminal cost, unlike tracking MPC.
• Real-World Example: In a chemical reactor, the cost function could be ( J = \sum \text{(Price of Feedstock - Value of Product + Cost of Utilities)} ), optimized in real-time against a dynamic process model.

Design elements added to the end of the prediction horizon to guarantee closed-loop stability, especially with short horizons.

• Terminal Cost: An additional term ( V_f(x_N) ) (e.g., from a Lyapunov function or Algebraic Riccati Equation) that penalizes the final state.
• Terminal Constraint: Requires the predicted state at the end of the horizon, ( x_N ), to lie within a terminal set ( \mathbb{X}_f ).
• Purpose: These components ensure the optimization approximates an infinite-horizon problem, providing a stability guarantee for the Receding Horizon Control law.

A method to implement soft constraints by adding slack variables to the cost function, preventing infeasibility of the Optimal Control Problem (OCP).

• Mechanism: A constraint like ( y_k \leq y_{max} ) is reformulated as ( y_k \leq y_{max} + \epsilon_k ) with ( \epsilon_k \geq 0 ). A large penalty weight ( \rho ) on ( \epsilon_k ) is added to the cost: ( J = ... + \rho \sum \epsilon_k^2 ).
• Use Case: Critical for output constraints that may become temporarily unavoidable due to large disturbances, allowing a small, penalized violation instead of controller failure.
• Trade-off: The weight ( \rho ) creates a tunable balance between constraint satisfaction and primary objective performance.

Used in Nonlinear MPC (NMPC) for problems where the performance metric is not adequately captured by a quadratic form.

• Formulation: ( J = \sum \ell(x_k, u_k) ), where ( \ell(\cdot) ) is a general nonlinear function.
• Common Types:
  • Minimum-Time: ( \ell = 1 ), minimizing the number of steps to reach a goal.
  • Obstacle Avoidance: High cost assigned to states inside obstacle regions.
  • Fuel-Optimal (L1 Norm): ( \ell = |u_k| ), minimizing absolute control effort, common in aerospace.
• Solver Impact: Requires more complex Nonlinear Programming (NLP) solvers like Sequential Quadratic Programming (SQP) or Interior-Point Methods.

Modified formulations that account for uncertainty in the dynamic model or disturbances.

• Worst-Case (Robust MPC): The cost is minimized for the worst-case realization of uncertainty within a bounded set (min-max optimization).
• Expected Value (Stochastic MPC): The cost is the expectation ( \mathbb{E}[J] ) taken over a distribution of possible disturbances or model parameters.
• Chance Constraints: System constraints are required to hold with a probability ( 1 - \alpha ). The cost function may include terms to minimize the risk of constraint violation.
• Result: These formulations yield controllers that are less aggressive but more reliable in the face of uncertainty, increasing robust stability.

The Optimal Control Problem (OCP) is the complete mathematical formulation solved at each step of MPC. It defines the search for a control sequence that minimizes a cost function subject to a dynamic model and constraints. The OCP is the formal container for the cost function, which acts as its primary objective.

• Core Components: Dynamic model equations, cost function, initial state, state/input constraints, and time horizon.
• Role of Cost Function: The cost function provides the scalar metric the OCP solver aims to minimize.
• Example: For a drone, the OCP finds throttle and steering inputs that minimize a cost combining position error and fuel use, while respecting motor limits.

A Quadratic Programming (QP) Solver is the numerical optimization engine that computes the solution to the OCP in Linear MPC. When the cost function is quadratic and constraints are linear, the OCP reduces to a QP. The solver's performance directly determines if MPC can run in real-time.

• Connection to Cost Function: The solver minimizes the quadratic cost function (e.g., tracking error² + control effort²).
• Critical Requirement: Must solve the QP within one controller sampling period (e.g., < 10ms).
• Common Algorithms: Active-set methods, interior-point methods, and specialized real-time iterations.

State constraints and input constraints are inequality bounds that define the safe and feasible operating region of the system. While the cost function defines what is optimal, these constraints define what is allowed. MPC explicitly enforces them over the prediction horizon.

• State Constraints: Limits on system variables (e.g., robot joint angles, tank levels, vehicle position).
• Input Constraints: Limits on actuator commands (e.g., motor torque, valve opening, steering angle).
• Interaction with Cost: The optimizer finds the control sequence that minimizes cost while satisfying all constraints. Infeasibility can be handled with soft constraints (penalized in the cost function).

A terminal cost is an additional term added to the end of the MPC cost function, and a terminal constraint requires the final predicted state to lie within a specific set. These are advanced design tools used primarily to guarantee closed-loop stability for the finite-horizon MPC controller.

• Terminal Cost: Often chosen as the cost-to-go from a stabilizing controller (e.g., Linear Quadratic Regulator). It approximates the cost of the infinite future beyond the horizon.
• Terminal Constraint: Forces the predicted state at the horizon's end into a known positively invariant set.
• Design Purpose: Together, they ensure the finite-horizon optimization has the same stabilizing properties as an infinite-horizon one.

Economic MPC is a variant where the cost function directly encodes a process economic or business objective, rather than a traditional technical objective like tracking error. The cost function becomes a direct measure of profit, energy consumption, or raw material cost.

• Cost Function Shift: Moves from (setpoint - output)² to (price * input - revenue * output).
• Example: In a chemical reactor, the cost function could be -(profit = value_of_product - cost_of_reactants - cost_of_heating).
• Challenge: Economic cost functions are often non-convex and non-quadratic, requiring Nonlinear MPC (NMPC) and more sophisticated solvers.

Sequential Quadratic Programming (SQP) is a leading iterative algorithm for solving the Nonlinear Programming (NLP) problems that arise in Nonlinear MPC (NMPC). It handles non-quadratic cost functions and nonlinear models by solving a series of approximate QP subproblems.

• Role in NMPC: When the cost function or model is nonlinear (e.g., aerodynamic drag, chemical kinetics), the OCP is an NLP. SQP is a standard method for its solution.
• Mechanism: At each iteration, it linearizes constraints and approximates the cost function as a quadratic (using the Hessian), creating a local QP to solve.
• Real-Time NMPC: Real-time iterations (RTI) of SQP, where only one QP is solved per time step, are crucial for practical NMPC.