modalreal

Compute modal state-space realization

Since R2023b

Syntax

[msys,blks] = modalreal(sys)

[msys,blks,TL,TR] = modalreal(sys)

[___] = modalreal(sys,Name=Value)

Description

[msys,blks] = modalreal(sys) returns a modal realization msys of an LTI model sys. This is a realization where A or (A,E) are block diagonal and each block corresponds to a real pole, a complex pair, or a cluster of repeated poles. blks is a vector containing block sizes down the diagonal.

[msys,blks,TL,TR] = modalreal(sys) also returns the block-diagonalizing transformations TL and TR.

[___] = modalreal(sys,Name=Value) specifies options for controlling the block size and normalizing 2-by-2 blocks associated with complex pairs.

Examples

Convert State-Space Model to Modal Form

pendulumCartSSModel.mat contains the state-space model of an inverted pendulum on a cart where the outputs are the cart displacement $\mathit{x}$ and the pendulum angle $\theta$. The control input u is the horizontal force on the cart.

$$\begin{array}{l}\left[\begin{array}{c}\underset{}{\overset{\dot{}}{x}}\\ \underset{}{\overset{¨}{x}}\\ \underset{}{\overset{\dot{}}{\theta }}\\ \underset{}{\overset{¨}{\theta }}\end{array}\right]=\left[\begin{array}{cccc}0& 1& 0& 0\\ 0& -0.1& 3& 0\\ 0& 0& 0& 1\\ 0& -0.5& 30& 0\end{array}\right]\left[\begin{array}{c}x\\ \underset{}{\overset{\dot{}}{x}}\\ \theta \\ \underset{}{\overset{\dot{}}{\theta }}\end{array}\right]+\left[\begin{array}{c}0\\ 2\\ 0\\ 5\end{array}\right]u\\ y=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 0& 1& 0\end{array}\right]\left[\begin{array}{c}x\\ \underset{}{\overset{\dot{}}{x}}\\ \theta \\ \underset{}{\overset{\dot{}}{\theta }}\end{array}\right]+\left[\begin{array}{c}0\\ 0\end{array}\right]u\end{array}$$

First, load the state-space model sys to the workspace.

load('pendulumCartSSModel.mat','sys');

Convert sys to modal form and extract the block sizes.

[msys,blks,TL,TR] = modalreal(sys)

msys =
 
  A = 
           x1      x2      x3      x4
   x1       0       0       0       0
   x2       0   -0.05       0       0
   x3       0       0  -5.503       0
   x4       0       0       0   5.453
 
  B = 
          u1
   x1  1.875
   x2  6.298
   x3   12.8
   x4  12.05
 
  C = 
              x1         x2         x3         x4
   y1         16     -4.763  -0.003696   0.003652
   y2          0   0.003969   -0.03663    0.03685
 
  D = 
       u1
   y1   0
   y2   0
 
Continuous-time state-space model.
Model Properties

blks = 4×1

     1
     1
     1
     1

TL = 4×4

    0.0625    1.2500   -0.0000   -0.1250
         0    4.1986    0.0210   -0.4199
         0    0.2285  -13.5873    2.4693
         0   -0.2251   13.6287    2.4995

TR = 4×4

   16.0000   -4.7631   -0.0037    0.0037
         0    0.2381    0.0203    0.0199
         0    0.0040   -0.0366    0.0369
         0   -0.0002    0.2015    0.2009

msys is the modal realization of sys, blks represents the block sizes down the diagonal, and TL and TR represent the block-diagonalizing transformation matrices.

Modal Realization of Zero-Pole-Gain Model

For this example, consider the following system with doubled poles and clusters of close poles:

$$sys\left(s\right)=100\frac{\left(s-1\right)\left(s+1\right)}{s\left(s+10\right)\left(s+10.0001\right){\left(s-\left(1+i\right)\right)}^2{\left(s-\left(1-i\right)\right)}^2}$$

Create a zpk model of this system and obtain a modal realization using the function modalreal.

sys = zpk([1 -1],[0 -10 -10.0001 1+1i 1-1i 1+1i 1-1i],100);
[msys1,blks1] = modalreal(sys);
blks1

blks1 = 3×1

     1
     4
     2

msys1.A

ans = 7×7

         0         0         0         0         0         0         0
         0    1.0000    2.1220         0         0         0         0
         0   -0.4713    1.0000    1.5296         0         0         0
         0         0         0    1.0000    1.8439         0         0
         0         0         0   -0.5423    1.0000         0         0
         0         0         0         0         0  -10.0000    4.0571
         0         0         0         0         0         0  -10.0001

msys1.B

ans = 7×1

    0.1600
   -0.0052
    0.0201
   -0.0975
    0.2884
         0
    4.0095

sys has a pair of poles at s = -10 and s = -10.0001, and two complex poles of multiplicity 2 at s = 1+i and s = 1-i. As a result, the modal form msys1 is a state-space model with a block of size 2 for the two poles near s = -10, and a block of size 4 for the complex eigenvalues.

Now, separate the two poles near s = -10 by increasing the condition number of the block-diagonalizing transformation. Set SepTol to 1e-10 for this example.

[msys2,blks2] = modalreal(sys,SepTol=1e-10);
blks2

blks2 = 4×1

     1
     4
     1
     1

msys2.A

ans = 7×7

         0         0         0         0         0         0         0
         0    1.0000    2.1220         0         0         0         0
         0   -0.4713    1.0000    1.5296         0         0         0
         0         0         0    1.0000    1.8439         0         0
         0         0         0   -0.5423    1.0000         0         0
         0         0         0         0         0  -10.0000         0
         0         0         0         0         0         0  -10.0001

msys2.B

ans = 7×1
105 ×

    0.0000
   -0.0000
    0.0000
   -0.0000
    0.0000
    1.6267
    1.6267

The A matrix of msys2 includes separate diagonal elements for the poles near s = -10. Increasing the condition number results in some very large values in the B matrix.

Normalize Diagonal Blocks in Modal Realizations

For this example, consider the following system with complex pair poles and clusters of close poles:

$$sys\left(s\right)=100\frac{\left(s-1\right)\left(s+1\right)}{s\left(s+10\right)\left(s+10.0001\right){\left(s-\left(3+4i\right)\right)}^2}$$

Create a zpk model of this system and obtain a modal realization using the function modalreal.

sys = zpk([1 -1],[0 -10 -10.0001 3+4i 3-4i],100);
[msys1,blks1] = modalreal(sys);
blks1

blks1 = 3×1

     1
     2
     2

msys1.A

ans = 5×5

         0         0         0         0         0
         0    3.0000    8.7637         0         0
         0   -1.8257    3.0000         0         0
         0         0         0  -10.0000    8.8001
         0         0         0         0  -10.0001

msys1 is a state-space model with a block of sizes 2 for the two poles near s = -10, and a pair of complex poles at s = 3+4i and s = 3-4i.

You can normalize the values of 2-by-2 blocks to show the actual pole values using the Normalize option. Additionally, relax the relative accuracy of the block diagonalizing transformation to separate the block near s = -10.

[msys2,blks2] = modalreal(sys,Normalize=true,SepTol=1e-10);
blks2

blks2 = 4×1

     1
     2
     1
     1

msys2.A

ans = 5×5

         0         0         0         0         0
         0    3.0000    4.0000         0         0
         0   -4.0000    3.0000         0         0
         0         0         0  -10.0000         0
         0         0         0         0  -10.0001

For complex poles, this option normalizes the 2-by-2 block of complex poles $\mathit{a}\pm \mathit{bi}$ to $\left[\begin{array}{cc}\mathit{a}& \mathit{b}\\ -\mathit{b}& \mathit{a}\end{array}\right]$.

Input Arguments

sys — Dynamic system

dynamic system model

Dynamic system, specified as a SISO, or MIMO dynamic system model. Dynamic systems that you can use include:

• Continuous-time or discrete-time numeric LTI models, such as tf, zpk, ss, or pid models.

• Generalized or uncertain LTI models such as genss or uss (Robust Control Toolbox) models. (Using uncertain models requires Robust Control Toolbox™ software.)

• Identified LTI models, such as idtf (System Identification Toolbox), idss (System Identification Toolbox), idproc (System Identification Toolbox), idpoly (System Identification Toolbox), and idgrey (System Identification Toolbox) models. (Using identified models requires System Identification Toolbox™ software.)

You cannot use frequency-response data models such as frd models.

Name-Value Arguments

Specify optional pairs of arguments as Name1=Value1,...,NameN=ValueN, where Name is the argument name and Value is the corresponding value. Name-value arguments must appear after other arguments, but the order of the pairs does not matter.

Example: [msys,blks] = modalreal(sys,Normalize=true)

SepTol — Relative accuracy of block diagonalization

1e-12 (default) | scalar between 0 and 1

Relative accuracy of block diagonalization, specified as a scalar between 0 and 1.

This option limits the condition number of the block diagonalizing transformation to roughly SepTol/eps. Increasing SepTol helps yield smaller blocks at the expense of accuracy.

Normalize — Normalize diagonal blocks

false or 0 (default) | true or 1

Normalize 1-by-1 and 2-by-2 diagonal blocks, specified as a logical 0 (false) or 1 (true).

When Normalize is true, the function normalizes the block to show the pole values.

• For explicit models, the function normalizes 2-by-2 blocks associated with complex pairs a±jb to $$\left[\begin{array}{cc}a& b\\ -b& a\end{array}\right]$$.

• For descriptor models, the function normalizes

  • 1-by-1 blocks to A_j = a, E_j = 1.

  • 2-by-2 blocks to A_j = $$\left[\begin{array}{cc}a& b\\ -b& a\end{array}\right]$$, E_j = I.

Output Arguments

msys — Modal state-space realization

ss model object

Modal state-space realization of the dynamic model, returned as an ss model object. msys is a realization where A or (A,E) are block diagonal and each block corresponds to a real pole, a complex pair, or a cluster of repeated poles.

blks — Block sizes

vector

Block sizes in the block-diagonal realization, returned as a vector.

TL — Left-side matrix of block-diagonalizing transformation

matrix | []

Left-side matrix of the block-diagonalizing transformation, returned as a matrix with dimensions Nx-by-Nx, where Nx is the number of states in the model sys.

The algorithm transforms the state-space realization (A, B, C, D, E) of a model to block diagonal matrices (A_m, B_m, C_m, D_m, E_m) given by:

• For explicit state-space models

  $$\begin{array}{l}\begin{array}{cc}{A}_m=T_{L}A{T}_R,& B_m=T_{L}B,\end{array}\\ \begin{array}{ccc}{C}_m=C{T}_R,& D_m=D,& E=T_L{T}_R=I\end{array}\end{array}$$

• For descriptor state-space models

  $$\begin{array}{l}\begin{array}{cc}{A}_m=T_{L}A{T}_R,& B_m=T_{L}B,\end{array}\\ \begin{array}{ccc}{C}_m=C{T}_R,& D_m=D,& E_m=T_{L}E{T}_R\end{array}\end{array}$$

The function returns an empty value [] for this argument when the input model sys is not a state-space model.

TR — Right-side matrix of block-diagonalizing transformation

matrix | []

Right-side matrix of the block-diagonalizing transformation, returned as a matrix with dimensions Nx-by-Nx, where Nx is the number of states in the model sys.The algorithm transforms the state-space realization (A, B, C, D, E) of a model to block diagonal matrices (A_m, B_m, C_m, D_m, E_m) given by:

• For explicit state-space models

  $$\begin{array}{l}\begin{array}{cc}{A}_m=T_{L}A{T}_R,& B_m=T_{L}B,\end{array}\\ \begin{array}{ccc}{C}_m=C{T}_R,& D_m=D,& E=T_L{T}_R=I\end{array}\end{array}$$

• For descriptor state-space models

  $$\begin{array}{l}\begin{array}{cc}{A}_m=T_{L}A{T}_R,& B_m=T_{L}B,\end{array}\\ \begin{array}{ccc}{C}_m=C{T}_R,& D_m=D,& E_m=T_{L}E{T}_R\end{array}\end{array}$$

The function returns an empty value [] for this argument when the input model sys is not a state-space model.

Version History

Introduced in R2023b