ss2sos

Convert digital filter state-space parameters to second-order sections form

collapse all in page

Syntax

[sos,g] = ss2sos(A,B,C,D)

[sos,g] = ss2sos(A,B,C,D,iu)

[sos,g] = ss2sos(A,B,C,D,order)

[sos,g] = ss2sos(A,B,C,D,iu,order)

[sos,g] = ss2sos(A,B,C,D,iu,order,scale)

sos = ss2sos(___)

Description

[sos,g] = ss2sos(A,B,C,D) returns second-order section form sos with gain g that is equivalent to the state-space system represented by input arguments A, B, C, and D. The input state-space system must be single-output and real.

example

[sos,g] = ss2sos(A,B,C,D,iu) specifies index iu that indicates which input of the state-space system A, B, C, D the function uses in the conversion.

[sos,g] = ss2sos(A,B,C,D,order) specifies the order of the rows in sos with order.

[sos,g] = ss2sos(A,B,C,D,iu,order) specifies both the index ui and the order of the rows order.

[sos,g] = ss2sos(A,B,C,D,iu,order,scale) specifies the desired scaling of the gain and the numerator coefficients of all second-order sections.

sos = ss2sos(___) embeds the overall system gain g in the first section. You can specify an input combination from any of the previous syntaxes.

Examples

collapse all

Second-Order Section Form of Filter

Open Live Script

Design a fifth-order Butterworth lowpass filter, specifying a cutoff frequency of $0.2 π$ rad/sample and expressing the output in state-space form. Convert the state-space result to second-order sections. Visualize the frequency response of the filter.

[A,B,C,D] = butter(5,0.2);
sos = ss2sos(A,B,C,D)

sos = 3×6

    0.0013    0.0013         0    1.0000   -0.5095         0
    1.0000    1.9996    0.9996    1.0000   -1.0966    0.3554
    1.0000    2.0000    1.0000    1.0000   -1.3693    0.6926

freqz(sos)

$Figure contains 2 axes objects. Axes object 1 with title Phase, xlabel Normalized Frequency (\times\pi rad/sample), ylabel Phase (degrees) contains an object of type line. Axes object 2 with title Magnitude, xlabel Normalized Frequency (\times\pi rad/sample), ylabel Magnitude (dB) contains an object of type line.$

Mass-Spring System

Open Live Script

A one-dimensional discrete-time oscillating system consists of a unit mass, $m$ , attached to a wall by a spring of unit elastic constant. A sensor measures the acceleration, $a$ , of the mass.

Mass-spring system, with a mass of 1 kilogram and a spring with elastic constant k=1 Newton per meter. The displacement of the mass is r (in meters).

The system is sampled at $F_{s} = 5$ Hz. Generate 50 time samples. Define the sampling interval $Δ t = 1 / F_{s}$ .

Fs = 5;
dt = 1/Fs;
N = 50;
t = dt*(0:N-1);

The oscillator can be described by the state-space equations

$\begin{array}{c} x (k + 1) = A x (k) + B u (k), \\ y (k) = C x (k) + D u (k), \end{array}$

where $x = {(\begin{array}{c} r & v \end{array})}^{T}$ is the state vector, $r$ and $v$ are respectively the position and velocity of the mass, and the matrices

$A = (\begin{array}{c} \cos Δ t & \sin Δ t \\ - \sin Δ t & \cos Δ t \end{array}), B = (\begin{array}{c} 1 - \cos Δ t \\ \sin Δ t \end{array}), C = (\begin{array}{c} - 1 & 0 \end{array}), D = (\begin{array}{c} 1 \end{array}) .$

A = [cos(dt) sin(dt);-sin(dt) cos(dt)];
B = [1-cos(dt);sin(dt)];
C = [-1 0];
D = 1;

The system is excited with a unit impulse in the positive direction. Use the state-space model to compute the time evolution of the system starting from an all-zero initial state.

u = [1 zeros(1,N-1)];

x = [0;0];
for k = 1:N
    y(k) = C*x + D*u(k);
    x = A*x + B*u(k);
end

Plot the acceleration of the mass as a function of time.

stem(t,y,"filled")

Figure contains an axes object. The axes object contains an object of type stem.

Compute the time-dependent acceleration using the transfer function to filter the input. Express the transfer function as second-order sections. Plot the result. The result is the same in both cases.

sos = ss2sos(A,B,C,D);
yt = sosfilt(sos,u);
stem(t,yt,"filled")

Figure contains an axes object. The axes object contains an object of type stem.

Input Arguments

collapse all

`A` — State matrix
matrix

State matrix, specified as a matrix. If the system has p inputs and q outputs and is described by n state variables, then A is of size n-by-n.

`B` — Input-to-state matrix
matrix

Input-to-state matrix, specified as a matrix. If the system has p inputs and q outputs and is described by n state variables, then B is of size n-by-p.

`C` — Output-to-state matrix
matrix

Output-to-state matrix, specified as a matrix. If the system has p inputs and q outputs and is described by n state variables, then C is of size q-by-n.

`D` — Feedthrough matrix
matrix

Feedthrough matrix, specified as a matrix. If the system has p inputs and q outputs and is described by n state variables, then D is of size q-by-p.

`iu` — Index
`1` (default) | integer

Index, specified as an integer.

`order` — Row order
`'up'` (default) | `'down'`

Row order in sos, specified as one of these values:

'down' — Order the sections so that the first row of sos contains the poles that are closest to the unit circle.
'up' — Order the sections so that the first row of sos contains the poles that are farthest from the unit circle.

The zeros are paired with the poles that are closest to them.

`scale` — Scaling of gain and numerator coefficients
`'none'` (default) | `'inf'`

Scaling of the gain and numerator coefficients, specified as one of these values:

'none' — Apply no scaling.
'inf' — Apply infinity-norm scaling.
'two' — Apply 2-norm scaling.

Using infinity-norm scaling in conjunction with up-ordering minimizes the probability of overflow in the realization. Using 2-norm scaling in conjunction with down-ordering minimizes the peak round-off noise.

Note

Infinity-norm and 2-norm scaling are appropriate for only direct-form II implementations.

Output Arguments

collapse all

`sos` — Second-order section representation
matrix

Second-order section representation, returned as a matrix. sos is an L-by-6 matrix of the form

$sos = [\begin{matrix} b_{01} & b_{11} & b_{21} & 1 & a_{11} & a_{21} \\ b_{02} & b_{12} & b_{22} & 1 & a_{12} & a_{22} \\ ⋮ & ⋮ & ⋮ & ⋮ & ⋮ & ⋮ \\ b_{0 L} & b_{1 L} & b_{2 L} & 1 & a_{1 L} & a_{2 L} \end{matrix}]$

whose rows contain the numerator and denominator coefficients b_ik and a_ik of the second-order sections of H(z), which is given by

$H (z) = g \prod_{k = 1}^{L} H_{k} (z) = g \prod_{k = 1}^{L} \frac{b_{0 k} + b_{1 k} z^{- 1} + b_{2 k} z^{- 2}}{1 + a_{1 k} z^{- 1} + a_{2 k} z^{- 2}}$

`g` — Overall system gain
real-valued scalar

Overall system gain, returned as a real-valued scalar.

If you call the function with one output argument, the function embeds the gain in the first section, H₁(z), so that

$H (z) = \prod_{l = 1}^{L} H_{l} (z) = H_{1} (z) \times H_{2} (z) \times \dots \times H_{L} (z) .$

Note

Embedding the gain in the first section when scaling a direct-form II structure is not recommended and can result in erratic scaling. To avoid embedding the gain, use the function with two outputs: sos and g.

Algorithms

The ss2sos function uses this four-step algorithm to determine the second-order section representation for an input state-space system.

Find the poles and zeros of the system given by A, B, C, and D.
Use the function zp2sos, which first groups the zeros and poles into complex conjugate pairs using the cplxpair function. zp2sos then forms the second-order sections by matching the pole and zero pairs according to these rules:
1. Match the poles that are closest to the unit circle with the zeros that are closest to those poles.
2. Match the poles that are next closest to the unit circle with the zeros that are closest to those poles.
3. Continue this process until all of the poles and zeros are matched.
The ss2sos function groups real poles into sections with the real poles that are closest to them in absolute value. The same rule holds for real zeros.
Order the sections according to the proximity of the pole pairs to the unit circle. The ss2sos function normally orders the sections with poles that are closest to the unit circle last in the cascade. You can specify for ss2sos to order the sections in the reverse order by setting the order input to 'down'.
Scale the sections by the norm specified by the scale input. For arbitrary H(ω), the scaling is defined by
${‖ H ‖}_{p} = {[\frac{1}{2 π} \int_{0}^{2 π} {| H (ω) |}^{p} d ω]}^{1 / p}$
where p can be either ∞ or 2. For details, see the references. This scaling is an attempt to minimize overflow or peak round-off noise in fixed-point filter implementations.

References

[1] Jackson, Leland B. Digital Filters and Signal Processing. Boston: Kluwer Academic Publishers, 1996.

[2] Mitra, Sanjit Kumar. Digital Signal Processing: A Computer-Based Approach. New York: McGraw-Hill, 1998.

[3] Vaidyanathan, P. P. “Robust Digital Filter Structures.” Handbook for Digital Signal Processing (S. K. Mitra and J. F. Kaiser, eds.). New York: John Wiley & Sons, 1993.

Extended Capabilities

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

Any character or string input must be a constant at compile time.

Version History

Introduced before R2006a

ss2sos

Syntax

Description

Examples

Second-Order Section Form of Filter

Mass-Spring System

Input Arguments

A — State matrix matrix

B — Input-to-state matrix matrix

C — Output-to-state matrix matrix

D — Feedthrough matrix matrix

iu — Index 1 (default) | integer

order — Row order 'up' (default) | 'down'

scale — Scaling of gain and numerator coefficients 'none' (default) | 'inf'

Output Arguments

sos — Second-order section representation matrix

g — Overall system gain real-valued scalar

Algorithms

References

Extended Capabilities

C/C++ Code Generation Generate C and C++ code using MATLAB® Coder™.

Version History

See Also

`A` — State matrix
matrix

`B` — Input-to-state matrix
matrix

`C` — Output-to-state matrix
matrix

`D` — Feedthrough matrix
matrix

`iu` — Index
`1` (default) | integer

`order` — Row order
`'up'` (default) | `'down'`

`scale` — Scaling of gain and numerator coefficients
`'none'` (default) | `'inf'`

`sos` — Second-order section representation
matrix

`g` — Overall system gain
real-valued scalar

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.