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.

example

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

example

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

example

Examples

collapse all

Convert State-Space Model to Modal Form

Open Live Script

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

$\begin{array}{l} [\begin{array}{c} x_{}^{˙} \\ x_{}^{¨} \\ θ_{}^{˙} \\ θ_{}^{¨} \end{array}] = [\begin{array}{ccc} 0 & 1 & 0 & 0 \\ 0 & - 0.1 & 3 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & - 0.5 & 30 & 0 \end{array}] [\begin{array}{c} x \\ x_{}^{˙} \\ θ \\ θ_{}^{˙} \end{array}] + [\begin{array}{c} 0 \\ 2 \\ 0 \\ 5 \end{array}] u \\ y = [\begin{array}{cccc} 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \end{array}] [\begin{array}{c} x \\ x_{}^{˙} \\ θ \\ θ_{}^{˙} \end{array}] + [\begin{array}{c} 0 \\ 0 \end{array}] 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

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

Open Live Script

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

$s y s (s) = 100 \frac{(s - 1) (s + 1)}{s (s + 10) (s + 10.0001) {(s - (1 + i))}^{2} {(s - (1 - i))}^{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

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

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

Open Live Script

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

$s y s (s) = 100 \frac{(s - 1) (s + 1)}{s (s + 10) (s + 10.0001) {(s - (3 + 4 i))}^{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 $a \pm bi$ to $[\begin{array}{c} a & b \\ - b & a \end{array}]$ .

Input Arguments

collapse all

`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

collapse all

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 $[\begin{matrix} a & b \\ - b & a \end{matrix}]$ .
For descriptor models, the function normalizes
- 1-by-1 blocks to A_j = a, E_j = 1.
- 2-by-2 blocks to A_j = $[\begin{matrix} a & b \\ - b & a \end{matrix}]$ , E_j = I.

Output Arguments

collapse all

`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{matrix} A_{m} = T_{L} A T_{R}, & B_{m} = T_{L} B, \end{matrix} \\ \begin{matrix} C_{m} = C T_{R}, & D_{m} = D, & E = T_{L} T_{R} = I \end{matrix} \end{array}$
For descriptor state-space models
$\begin{array}{l} \begin{matrix} A_{m} = T_{L} A T_{R}, & B_{m} = T_{L} B, \end{matrix} \\ \begin{matrix} C_{m} = C T_{R}, & D_{m} = D, & E_{m} = T_{L} E T_{R} \end{matrix} \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{matrix} A_{m} = T_{L} A T_{R}, & B_{m} = T_{L} B, \end{matrix} \\ \begin{matrix} C_{m} = C T_{R}, & D_{m} = D, & E = T_{L} T_{R} = I \end{matrix} \end{array}$
For descriptor state-space models
$\begin{array}{l} \begin{matrix} A_{m} = T_{L} A T_{R}, & B_{m} = T_{L} B, \end{matrix} \\ \begin{matrix} C_{m} = C T_{R}, & D_{m} = D, & E_{m} = T_{L} E T_{R} \end{matrix} \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

modalreal

Syntax

Description

Examples

Convert State-Space Model to Modal Form

Modal Realization of Zero-Pole-Gain Model

Normalize Diagonal Blocks in Modal Realizations

Input Arguments

`sys` — Dynamic system
dynamic system model

Name-Value Arguments

`SepTol` — Relative accuracy of block diagonalization
`1e-12` (default) | scalar between 0 and 1

`Normalize` — Normalize diagonal blocks
`false` or `0` (default) | `true` or `1`

Output Arguments

`msys` — Modal state-space realization
`ss` model object

`blks` — Block sizes
vector

`TL` — Left-side matrix of block-diagonalizing transformation
matrix | `[]`

`TR` — Right-side matrix of block-diagonalizing transformation
matrix | `[]`

Version History

See Also

Topics

modalreal

Syntax

Description

Examples

Convert State-Space Model to Modal Form

Modal Realization of Zero-Pole-Gain Model

Normalize Diagonal Blocks in Modal Realizations

Input Arguments

sys — Dynamic system dynamic system model

Name-Value Arguments

SepTol — Relative accuracy of block diagonalization 1e-12 (default) | scalar between 0 and 1

Normalize — Normalize diagonal blocks false or 0 (default) | true or 1

Output Arguments

msys — Modal state-space realization ss model object

blks — Block sizes vector

TL — Left-side matrix of block-diagonalizing transformation matrix | []

TR — Right-side matrix of block-diagonalizing transformation matrix | []

Version History

See Also

Topics

`sys` — Dynamic system
dynamic system model

`SepTol` — Relative accuracy of block diagonalization
`1e-12` (default) | scalar between 0 and 1

`Normalize` — Normalize diagonal blocks
`false` or `0` (default) | `true` or `1`

`msys` — Modal state-space realization
`ss` model object

`blks` — Block sizes
vector

`TL` — Left-side matrix of block-diagonalizing transformation
matrix | `[]`

`TR` — Right-side matrix of block-diagonalizing transformation
matrix | `[]`