Skip to main content

Control synthesis

Overview

LPVcore contains state-of-the-art analysis and controller synthesis algorithms for several model structures. On this page, a brief overview is given of the functionality available to perform analysis and controller synthesis. Firstly, an overview of the available analysis methods is provided. Secondly, the available algorithms for controller synthesis are presented. Finally, a short description of the algorithms that are used to solve the analysis and controller synthesis problems is given.

Analysis

General information

Through the lpvnorm function, several methods are available to analyze the performance (and stability) of LPV systems. The supported LPV representations are LPVcore.lpvss and LPVcore.lpvidss objects with an affine scheduling-dependency, i.e., of the form

ξx=A(p)x+B(p)u,y=C(p)x+D(p)u,\begin{aligned} \xi x &= A(p) x + B(p) u, \\[4pt] y &= C(p) x + D(p)u , \end{aligned}

where xx is the state of the model, uu its input, and yy its output, ξ=ddt\xi=\frac{d}{dt} in continuous-time and ξ=q1\xi=q^{-1} in discrete-time. Moreover, AA, BB, CC, and DD are matrix functions of the form M(p)=M0+i=1npMipiM(p) = M_0 + \sum_{i=1}^{n_\mathrm{p}}M_i \, p_i. Furthermore, grid-based LPV representations as LPVcore.lpvgridss objects are also supported by lpvnorm.

In the following table, an overview of the available performance metrics that can be analyzed is given. The corresponding type option for the lpvnorm command for each performance metric is also indicated. By default, if type is not specified, l2 is used.

Performance metricIO relation*Command
Induced L2L_2-gainy2γu2\Vert y \Vert_2\leq\gamma\Vert u\Vert_2lpvnorm(sys,'l2')
Induced LL_\infty-gainyγu\Vert y \Vert_\infty\leq\gamma\Vert u\Vert_\inftylpvnorm(sys,'linf')
Generalized H2H_2 normyγu2\Vert y \Vert_\infty\leq\gamma\Vert u\Vert_2lpvnorm(sys,'h2')
Passivity0Ty(t)u(t)dt0\int_0^T y(t)^\top u(t)\,dt\geq 0lpvnorm(sys,'passive')

*'\Vert\cdot\Vert' denotes the signal norm, see Definition 2.8 in [1] for more details.

The following code snippet shows how the induced L2L_2-gain of an LPV model can be computed:

p = preal('p', 'ct', 'Range', [0, 9]);

A = [0 1; - 1 - p, -3];
B = [0;1];
C = [1 0];
D = 0;
model = LPVcore.lpvss(A, B, C, D);

gam = lpvnorm(model, 'l2');

See synthesis/example_lpvnorm.m for more detailed examples.

Analysis options

Several options are available for lpvnorm. Namely, the following name-value pairs are available:

  • SolverOptions: A structure containing the YALMIP solver settings. See also help sdpsettings. Default value: sdpsettings('verbose',0,'solver','sdpt3').
  • NumericalAccuracy: An option to set the numerical accuracy parameter. A positive number that is used to ensure that the solved LMIs are negative or positive definite by enforcing that LMIαI\mathrm{LMI} \preceq -\alpha I or LMIαI\mathrm{LMI} \succeq \alpha I, respectively, where α\alpha is the value of the numerical accuracy parameter. Default value: 1e-10.
  • LinfOptions: A structure containing the options for LL_\infty based analysis. It needs to be constructed by using the linfOptions command. See below for more details. Default value: linfOptions().
  • ParameterVaryingStorage: An option to indicate whether a parameter-varying storage function is considered (if at least one of the scheduling-variables has finite rate-bounds). Use 0 to indicate using a parameter-independent storage function, 1 to indicate parameter-dependency on all parameters with finite rate-bounds. For LPVcore.lpvgridss models, the user must specify a 'template storage function' in order to use a parameter-varying storage function. This template storage function is used in order to specify the parameter dependency of the used parameter-varying storage function. For example:
    >> p = preal('p', 'ct', 'RateBound', [-1 1]');
    >> stor = 1 + p + p^2;
    >> lpvnorm(sys, 'l2', 'ParameterVaryingStorage', stor)
    All the used parameters of the template storage function should have their rate bounds specified and their names should match the parameter names of the considered LPVcore.lpvgridss model. In continuous-time, the template storage function can only have a polynomial dependency, i.e., custom basis function through pbcustom cannot be used. Default value: 1 (for LPVcore.lpvss models), 0 (for LPVcore.lpvgridss models).
  • Verbose: Option to turn progress messages on, 1, or off, 0. Default value: 1.

The options can be used by adding them as input arguments to the lpvnorm command, for example:

gam = lpvnorm(model, 'l2', 'Verbose', 0, 'NumericalAccuaracy', 1e-8);

or

gam = lpvnorm(model, 'l2', Verbose = 0, NumericalAccuaracy = 1e-8);

Controller synthesis

Output Feedback Synthesis

General information

The lpvsyn command allows the user to synthesize various optimal (output-feedback) LPV state-space controllers KK for a given state-space LPV (generalized) plant PP. Like for analysis, the lpvsyn command supports LPVcore.lpvss and LPVcore.lpvidss objects with an affine scheduling dependency, as well as LPVcore.lpvgridss objects.

It is assumed that the plant PP is of the form

ξx=A(p)x+Bw(p)w+Bu(p)u,z=Cz(p)x+Dzw(p)w+Dzu(p)u,y=Cy(p)x+Dyw(p)w.\begin{aligned} \xi x &= A(p) x + B_\mathrm{w}(p)w + B_\mathrm{u}(p) u, \\[4pt] z &= C_\mathrm{z}(p)x + D_\mathrm{zw}(p)w + D_\mathrm{zu}(p) u,\\[4pt] y &= C_\mathrm{y}(p) x +D_\mathrm{yw}(p)w . \end{aligned}

where xx is the state of the model, uu its control input, yy its measured output, ww is the (generalized) disturbance channel, and zz is the (generalized) performance channel.

info

For controller synthesis for affine LPVcore.lpvss and LPVcore.lpvidss objects, it is assumed that Bu,B_\mathrm{u}, Cy,C_\mathrm{y}, Dzu,D_\mathrm{zu}, and DywD_\mathrm{yw} are constant matrices.

The synthesized controller KK resulting from running lpvsyn is of the form

ξxk=Ak(p)xk+Bk(p)uk,yk=Ck(p)xk+Dk(p)uk,\begin{aligned} \xi x_\mathrm{k} &= A_\mathrm{k}(p) x_\mathrm{k} + B_\mathrm{k}(p) u_\mathrm{k}, \\[4pt] y_\mathrm{k} &= C_\mathrm{k}(p) x_\mathrm{k} +D_\mathrm{k}(p)u_\mathrm{k} , \end{aligned}

which is connected to PP as in the following figure:

Closed Interconnection of P and K

By default, for the closed-loop of PP and KK, the L2L_2-gain from ww to zz is minimized to synthesize KK. The considered performance metric can be adjusted by changing the Performance option through lpvsynOptions or by using one of the performance-specific synthesis functions, i.e., lpvl2syn, lpvlinfsyn, lpvh2syn, or lpvpassyn. The available performance metrics are given in the table below.

Performance metricIO relation*Command
Induced L2L_2-gainy2γu2\Vert y \Vert_2\leq\gamma\Vert u\Vert_2Setting lpvsynOptions('Performance,'l2') for lpvsyn or using lpvl2syn
Induced LL_\infty-gainyγu\Vert y \Vert_\infty\leq\gamma\Vert u\Vert_\inftySetting lpvsynOptions('Performance,'linf') for lpvsyn or using lpvlinfsyn
Generalized H2H_2 normyγu2\Vert y \Vert_\infty\leq\gamma\Vert u\Vert_2Setting lpvsynOptions('Performance,'h2') for lpvsyn or using lpvh2syn
Passivity0Ty(t)u(t)dt0\int_0^T y(t)^\top u(t)\,dt\geq 0Setting lpvsynOptions('Performance,'passive') for lpvsyn or using lpvpasssyn

The following code snippet shows how an L2L_2-gain optimal LPV controller can be synthesized for a plant PP:

p = preal('p', 'ct', 'Range', [0, 9]);

A = [0 1; - 1 - p, -3];
B = [0 0;0 1];
C = [-1 0;-1 0];
D = [1 0;1 0];
P = LPVcore.lpvss(A, B, C, D);

ny = 1;
nu = 1;

[K, gam] = lpvsyn(P, ny, nu);

See synthesis/example_lpvsyn.m for more detailed examples.

Synthesis options

Various options related to controller synthesis can be set using the lpvsynOptions function. The following options, specified as name-value pairs, are available:

  • Backoff: The factor which is used to back off from the optimal gain γ\gamma that is found (to αγ\alpha\cdot\gamma, where α\alpha is the Backoff value) in order to reduce numerical errors, since the true optimal solution is often close to singular. Default value: 1.01.
  • Dependency: A logical array (1x4 or 4x1) which indicates which controller matrices, corresponding to AA, BB, CC and DD-matrix, should have parameter-dependency. In case of the transformation method, these apply to the transformed controller matrices, i.e., Ak\mathcal{A}_\mathrm{k}, Bk\mathcal{B}_\mathrm{k}, Ck\mathcal{C}_\mathrm{k}, and Dk\mathcal{D}_\mathrm{k} in Section 2.5.3. in [1] or similarly KK, LL, MM, and NN in Section 4.2.2. in [5]. Default value: [1 1 1 1].
  • DirectFeedthrough: An option to indicate if the synthesized controller should have direct feedthrough 1 or not 0, i.e., if the controller has a DkD_\mathrm{k}-matrix or not. Default value: 1.
  • ImproveConditioning: An option to indicate if extra optimization problems are solved to improve the conditioning of the found solutions. Default value: 1.
  • LinfOptions: An option to set the options for LL_\infty-based controller synthesis. Needs to be constructed by using the linfOptions command. See below for more details. Default value: linfOptions().
  • Method: An option to indicate what method to use internally to solve the controller synthesis problem. Possible values are transformation and projection. Using transformation, a nonlinear transformation is applied to the unknown variables (such as the controller matrices) in order to construct the LMIs for controller synthesis. The optimization problem is solved in these new variables, which are then used to compute the controller state-space matrices AkA_\mathrm{k}, BkB_\mathrm{k}, CkC_\mathrm{k}, and DkD_\mathrm{k} through the nonlinear transformation. Using projection, the controller state-space matrices are 'projected' away from the LMIs. Then, the optimization problem is solved for these LMIs which do not contain the controller state-space matrices. Then, an extra LMI is solved, corresponding to the closed-loop system containing the controller state-space matrices as unknowns, in order to obtain the controller state-space matrices. The transformation method often gives better numerical results. However, for continuous-time systems, only the projection method allows for controller synthesis with a parameter-varying storage function. Default value: transformation. NumericalAccuracy: An option to set the numerical accuracy parameter. A positive number that is used to ensure that the solved LMIs are negative or positive definite by enforcing that LMIαI\mathrm{LMI} \preceq -\alpha I or LMIαI\mathrm{LMI} \succeq \alpha I, respectively, where α\alpha is the value of the numerical accuracy parameter. Default value: 1e-8.
  • ParameterVaryingStorage: An option to indicate whether a parameter-varying storage function is considered (if at least one of the scheduling-variables has finite rate-bounds). Use 0 to indicate using a parameter-independent storage function, 1 to indicate parameter-dependency on all parameters with finite rate-bounds, or set to [] to let lpvsyn decide if an parameter-varying storage function can be used or not. Similar as for lpvnorm, for LPVcore.lpvgridss models the user must specify a 'template storage function' in order to use a parameter-varying storage function. This template storage function is used in order to specify the parameter dependency of the used parameter-varying storage function. For example:
    >> p = preal('p', 'ct', 'RateBound', [-1 1]');
    >> stor = 1 + p + p^2;
    >> lpvnorm(sys, 'l2', 'ParameterVaryingStorage', stor)
    All the used parameters of the template storage function should have their rate bounds specified and their names should match the parameter names of the considered LPVcore.lpvgridss model. In continuous-time, the template storage function can only have a polynomial dependency, i.e., custom basis function through pbcustom cannot be used. Default value: [] (for LPVcore.lpvss models), 0 (for LPVcore.lpvgridss models).
  • ParameterVaryingStorageOption: This options allows the user to choose between two different parameter-varying storage parameterizations. More specifically, this allows the user to either synthesize a controller corresponding third (by setting this option to 1) or fourth row (by setting this option to 2) in Table I in [3]. Neither option is in general better and which option will achieve better performance will depend on the specific control problem (and plant) that is considered. This option is currently only available for continuous-time controller synthesis problems. Default value: 1.
  • Performance: An option to set the performance metric that is considered for controller synthesis. Possible values are: 'linf', 'l2', 'h2', and 'passive'. Default value: 'l2'.
  • PoleConstraint: An option to set constraints on the closed-loop eigenvalues for controller synthesis. It needs to be constructed using the poleConstraintOptions command. See below for more details. Default value: poleConstraintOptions().
  • SolverOptions: A structure containing the YALMIP solver settings. See also help sdpsettings. Default value: sdpsettings('verbose', 0, 'solver', 'sdpt3').
  • Verbose: An option to turn progress messages on, 1, or off, 0. Default value: 1.

Usage example:

synOptions = lpvsynOptions('Backoff', 1.1, 'Performance', 'linf');

or

synOptions = lpvsynOptions(Backoff = 1.1, Performance = 'linf');

The synOptions variable can then be used with lpvsyn as follows:

K = lpvsyn(sys, ny, nu, synOptions);

State-feedback synthesis

General information

The lpvsynsf command allows the user to synthesize state-feedback LPV controllers KK for a state-space LPV (generalized) plant PP. Similar to output-feedback controller synthesis using lpvsyn, the lpvsynsf command supports LPVcore.lpvss and LPVcore.lpvidss objects with an affine scheduling dependency, as well as LPVcore.lpvgridss objects.

For state-feedback synthesis, it is assumed that the plant PP is of the form

ξx=A(p)x+Bw(p)w+Bu(p)u,z=Cz(p)x+Dzw(p)w+Dzu(p)u,\begin{aligned} \xi x &= A(p) x + B_\mathrm{w}(p)w + B_\mathrm{u}(p) u, \\[4pt] z &= C_\mathrm{z}(p)x + D_\mathrm{zw}(p)w + D_\mathrm{zu}(p) u,\\[4pt] \end{aligned}

where again xx is the state of the model, uu its control input, ww is the (generalized) disturbance channel, and zz is the (generalized) performance channel.

The synthesized controller KK resulting from running lpvsynsf is of the form

u=K(p)xu = K(p)x

and is given as a parameter-varying matrix object KK.

By default, the L2L_2-gain from ww to zz is minimized to synthesize KK. Similarly, as for lpvsyn, the considered performance metric can be adjusted by changing the Performance option through lpvsynsfOptions or by using one of the performance-specific synthesis functions, i.e., lpvl2synsf, lpvlinfsynsf, lpvh2synsf, or lpvpassynsf. The available performance metrics are given in the table below.

Performance metricIO relation*Command
Induced L2L_2-gainy2γu2\Vert y \Vert_2\leq\gamma\Vert u\Vert_2Setting lpvsynsfOptions('Performance,'l2') for lpvsynsf or using lpvl2synsf
Induced LL_\infty-gainyγu\Vert y \Vert_\infty\leq\gamma\Vert u\Vert_\inftySetting lpvsynsfOptions('Performance,'linf') for lpvsynsf or using lpvlinfsynsf
Generalized H2H_2 normyγu2\Vert y \Vert_\infty\leq\gamma\Vert u\Vert_2Setting lpvsynsfOptions('Performance,'h2') for lpvsynsf or using lpvh2synsf
Passivity0Ty(t)u(t)dt0\int_0^T y(t)^\top u(t)\,dt\geq 0Setting lpvsynsfOptions('Performance,'passive') for lpvsynsf or using lpvpasssynsf

The following code snippet shows how an L2L_2-gain optimal state-feedback LPV controller can be synthesized for a plant PP:

p = preal('p', 'ct', 'Range', [0, 9]);

A = [0 1; - 1 - p, -3];
B = [0 0;0 1];
C = [-1 0];
D = [1 0];
P = LPVcore.lpvss(A, B, C, D);

nu = 1;

[K, gam] = lpvsynsf(P, nu);

See synthesis/example_lpvsynsf.m for more detailed examples.

Synthesis options

Various options related to state-feedback controller synthesis can be set using the lpvsynsfOptions function. The majority of the options specified by lpvsynsfOptions are the same as the ones in lpvsynOptions, see above. Next, we will list all options that are available, and we will give a description for the options that differ from the ones of lpvsynOptions.

  • Backoff
  • Dependency: A logical value which indicates if the state-feedback matrix KK should be parameter-dependent, 1, or not, 0. Default value: 1.
  • ImproveConditioning
  • LinfOptions
  • NumericalAccuracy
  • ParameterVaryingStorage
  • ParameterVaryingStorageOption
  • Performance
  • PoleConstraint
  • SolverOptions
  • Verbose

Usage example:

synOptions = lpvsynsfOptions('Backoff', 1.1, 'Performance', 'linf');

or

synOptions = lpvsynsfOptions(Backoff = 1.1, Performance = 'linf');

The synOptions variable can then be used with lpvsynsf as follows:

K = lpvsynsf(sys, nu, synOptions);

General Options

LL_\infty-based analysis and controller synthesis options

Analysis and controller synthesis for LL_\infty performance work by carrying out a line-search over a slack variable λ\lambda in order to compute the minimal LL_\infty-gain that the system satisfies. The line-search works by first optimizing γ\gamma (which corresponds to the LL_\infty-gain) for a fixed number of values for λ\lambda. Afterwards, a bisection-based search algorithm (based on the Golden-ratio) is used between the interval of λ\lambda's that attain the lowest γ\gamma's in order to optimize the value of γ\gamma further. In order to adjust the settings related to this procedure, the user can use the linfOptions command. The command allows the user to adjust the following settings by specifying name-value pairs:

  • AccuracyLambda: Allows specifying the maximum λ\lambda search interval during the bisection-based search. If the λ\lambda interval is smaller than this value, the search is completed. Default value: 1e-3.
  • LambdaGrid: Array of values for λ\lambda used for initial line-search. Default value: linspace(1e-8, 5, 15).
  • MaxIterations: Maximum number of iterations for the bisection-based search phase. Default value: 25.

Usage example:

linfOpt = linfOptions('AccuracyLambda', 1e-4, 'MaxIterations', 30);

or

linfOpt = linfOptions(AccuracyLambda = 1e-4, MaxIterations = 30);

Pole constraint options

info

Support for pole constraints is currently only supported for continuous-time controller synthesis.

For controller synthesis, the closed-loop eigenvalues for frozen values of the scheduling-variable can be restricted to lie in a certain region in the complex plane. These constraints can be specified through the poleConstraintOptions command. Several regions can be specified as name-value pairs through the command. The options that are available are given in the table below. Specifying multiple constraint regions results in the intersection of these regions being taken as a constraint.

NameDescriptionInequalityFigure
CircleConstraint eigenvalues to an open circle with radius α\alphaz<α\vert z \vert<\alpha with α>0\alpha>0Circle pole constraint
LeftHalfPlaneConstraint eigenvalues to lie in the open left half-planeRe(z)<α\mathrm{Re}(z) < \alpha with αR\alpha\in\mathbb{R}Left half-plane pole constraint
RightHalfPlaneConstraint eigenvalues to lie in the open right half-planeRe(z)>α\mathrm{Re}(z) > \alpha with αR\alpha\in\mathbb{R}Right half-plane pole constraint
SectorConstraint eigenvalues to a sector in the left half-plane with an angle of α\alpha [rad]Re(z)tan(α)<Im(z)\mathrm{Re}(z)\tan(\alpha) < - \vert \mathrm{Im}(z) \vert with α>0\alpha>0Sector pole constraint
CustomA custom region specified by a structure with the fields Q, S, T, and U.[Iz][QSSR][Iz]<0\begin{bmatrix}I\\z\end{bmatrix}^*\begin{bmatrix}Q & S\\S^\top & R\end{bmatrix}\begin{bmatrix}I\\z\end{bmatrix} < 0 where R0R\succeq 0 and R=TU1TR=T^\top U^{-1}T

Usage example:

poleOpt = poleConstraintOptions('Circle',2,'Custom',struct('Q', -3, 'S', 1, 'T', 0, 'U', 1));

or

poleOpt = poleConstraintOptions(Circle = 2, Custom = struct('Q', -3, 'S', 1, 'T', 0, 'U', 1));

Algorithms

To solve the analysis and controller synthesis problem for LPV models for different performance metrics, the concept of dissipativity is used with a quadratic (parameter-dependent) storage function (also see Section 2.5.2 in [1]). This allows the analysis and controller synthesis problems to be cast as a set of Linear Matrix Inequalities (LMIs), corresponding to a Semidefinite Program (SDP), which can be solved efficiently using various SDP solvers.

The LMIs, along with their derivations, that are solved internally when calling lpvnorm can be found in Corollaries 2.1 to 2.4 in [1]. For output-feedback controller synthesis, when calling lpvsyn, the LMIs can be found in Corollaries 2.5 to 2.8 in [1]. For state-feedback controller synthesis, when calling lpvsynsf, the LMIs can be found in the following document: LPV State-Feedback LMI Derivations (PDF). To efficiently construct the LMIs and allow them to be parsed by various solvers, the YALMIP toolbox for MATLAB is used.

For affine LPV representations, the set of LMIs for the analysis and controller synthesis problems corresponds to the vertices of the convex scheduling set. This corresponds to so-called polytopic LPV methods to solve the problem, see e.g. [2] for more details in the L2L_2-gain case. To help with the construction of the LMIs for this case, the ROLMIP toolbox for MATLAB is used. For LPVcore.lpvgridss objects, the set of LMIs corresponds to each grid point. This corresponds to so-called grid(ding)-based LPV methods to solve the problem, see e.g. [3]. See also Section II.a and II.c in [4] for more details and references on polytopic and grid(ding)-based LPV methods.

References

[1]: Koelewijn, P.J.W., 'Analysis and Control of Nonlinear Systems with Stability and Performance Guarantees: A Linear Parameter-Varying Approach', PhD Thesis, Electrical Engineering, Eindhoven, 2023.

[2]: Apkarian, P., Gahinet, P., and Becker, G., 'Self-Scheduled Hinf Control of Linear Parameter-Varying Systems: A design example,' Automatica, 1995.

[3]: Apkarian, P., and Adams, R.J., 'Advanced gain-scheduling techniques for uncertain systems,' IEEE Transactions on Automatic Control, 1998.

[4]: Hoffmann, C., and Werner, H., 'A Survey of Linear Parameter-Varying Control Applications Validated by Experiments or High-Fidelity Simulations', IEEE Transaction on Control Systems Technology, 2015.

[5]: Scherer, C. W. and Weiland, S. (Jan. 2015). 'Linear Matrix Inequalities in Control'.