## Documentation Center |

Create zero-pole-gain model; convert to zero-pole-gain model

`sys = zpk(z,p,k) `

sys = zpk(z,p,k,Ts)

sys = zpk(M)

sys = zpk(z,p,k,ltisys)

s = zpk('s')

z = zpk('z',Ts)

zsys = zpk(sys)

zsys = zpk(sys,
'measured')

zsys = zpk(sys, 'noise')

zsys = zpk(sys, 'augmented')

Used `zpk` to create zero-pole-gain models
(`zpk` model objects), or to convert dynamic systems
to zero-pole-gain form.

` sys = zpk(z,p,k) `
creates a continuous-time zero-pole-gain model with zeros

In the SISO case, `z` and `p` are
the vectors of real- or complex-valued zeros and poles, and `k` is
the real- or complex-valued scalar gain:

Set `z` or `p` to `[]` for
systems without zeros or poles. These two vectors need not have equal
length and the model need not be proper (that is, have an excess of
poles).

To create a MIMO zero-pole-gain model, specify the zeros, poles, and gain of each SISO entry of this model. In this case:

`z`and`p`are cell arrays of vectors with as many rows as outputs and as many columns as inputs, and`k`is a matrix with as many rows as outputs and as many columns as inputs.The vectors

`z{i,j}`and`p{i,j}`specify the zeros and poles of the transfer function from input`j`to output`i.``k(i,j)`specifies the (scalar) gain of the transfer function from input`j`to output`i`.

`sys = zpk(z,p,k,Ts) ` creates
a discrete-time zero-pole-gain model with sample time `Ts` (in
seconds). Set `Ts = -1` or `Ts = []` to
leave the sample time unspecified. The input arguments `z`, `p`, `k` are
as in the continuous-time case.

`sys = zpk(M) ` specifies a static gain `M`.

`sys = zpk(z,p,k,ltisys) `
creates a zero-pole-gain model with properties inherited from the
LTI model `ltisys` (including the sample time).

To create an array of `zpk` model objects,
use a `for` loop, or use multidimensional cell arrays
for `z` and `p`, and a multidimensional
array for `k`.

Any of the previous syntaxes can be followed by property name/property value pairs.

'PropertyName',PropertyValue

Each pair specifies a particular property of the model, for
example, the input names or the input delay time. For more information
about the properties of `zpk` model objects, see Properties. Note that

sys = zpk(z,p,k,'Property1',Value1,...,'PropertyN',ValueN)

is a shortcut for the following sequence of commands.

sys = zpk(z,p,k) set(sys,'Property1',Value1,...,'PropertyN',ValueN)

You can also use rational expressions to create a ZPK model. To do so, first type either:

`s = zpk('s')`to specify a ZPK model using a rational function in the Laplace variable,`s`.`z = zpk('z',Ts)`to specify a ZPK model with sample time`Ts`using a rational function in the discrete-time variable,`z`.

Once you specify either of these variables, you can specify
ZPK models directly as rational expressions in the variable `s` or `z` by
entering your transfer function as a rational expression in either `s` or `z`.

`zsys = zpk(sys) ` converts
an arbitrary LTI model `sys` to zero-pole-gain form.
The output `zsys` is a ZPK object. By default, `zpk` uses `zero` to
compute the zeros when converting from state-space to zero-pole-gain.
Alternatively,

zsys = zpk(sys,'inv')

uses inversion formulas for state-space models to compute the
zeros. This algorithm is faster but less accurate for high-order models
with low gain at *s* = 0.

An identified model is represented by an input-output equation
of the form `y(t) = Gu(t) + He(t)`, where `u(t)` is
the set of measured input channels and `e(t)` represents
the noise channels. If *Λ= LL'* represents
the covariance of noise `e(t)`, this equation can
also be written as `y(t) = Gu(t) + HLv(t)`, where `cov(v(t))
= I`.

`zsys = zpk(sys)`, or `zsys = zpk(sys,
'measured')` converts the measured component of an identified
linear model into the ZPK form. `sys` is a model
of type `idss`, `idproc`, `idtf`, `idpoly`,
or `idgrey`. `zsys` represents the
relationship between `u` and `y`.

`zsys = zpk(sys, 'noise')` converts the noise
component of an identified linear model into the ZPK form. It represents
the relationship between the noise input, `v(t)` and
output, `y_noise = HL v(t)`. The noise input channels
belong to the `InputGroup` `'Noise'`.
The names of the noise input channels are `v@yname`,
where `yname` is the name of the corresponding output
channel. `zsys` has as many inputs as outputs.

`zsys = zpk(sys, 'augmented')` converts both
the measured and noise dynamics into a ZPK model. `zsys` has `ny+nu` inputs
such that the first `nu` inputs represent the channels `u(t)` while
the remaining by channels represent the noise channels `v(t)`. `zsys.InputGroup` contains
2 input groups, `'measured'` and `'noise'`.
`zsys.InputGroup.Measured` is set to `1:nu` while `zsys.InputGroup.Noise` is
set to `nu+1:nu+ny. zsys` represents the equation `y(t)
= [G HL] [u; v]`.

As for transfer functions, you can specify which variable to
use in the display of zero-pole-gain models. Available choices include *s* (default)
and *p* for continuous-time models, and *z* (default), *z ^{-1}*,

Create the continuous-time SISO transfer function:

Create *h*(*s*) as a `zpk` object
using:

h = zpk(0, [1-i 1+i 2], -2);

Specify the following one-input, two-output zero-pole-gain model:

To do this, enter:

z = {[] ; -0.5}; p = {0.3 ; [0.1+i 0.1-i]}; k = [1 ; 2]; H = zpk(z,p,k,-1); % unspecified sample time

Convert the transfer function

h = tf([-10 20 0],[1 7 20 28 19 5]);

to zero-pole-gain form, using:

zpk(h)

This command returns the result:

Zero/pole/gain: -10 s (s-2) ---------------------- (s+1)^3 (s^2 + 4s + 5)

Create a discrete-time ZPK model from a rational expression
in the variable `z`.

z = zpk('z',0.1); H = (z+.1)*(z+.2)/(z^2+.6*z+.09)

This command returns the following result:

Zero/pole/gain: (z+0.1) (z+0.2) --------------- (z+0.3)^2 Sampling time: 0.1

Create a MIMO `zpk` model using cell arrays
of zeros and poles.

Create the two-input, two-output zero-pole-gain model

by entering:

Z = {[],-5;[1-i 1+i] []}; P = {0,[-1 -1];[1 2 3],[]}; K = [-1 3;2 0]; H = zpk(Z,P,K);

Use `[]` as a place holder in `Z` or `P` when
the corresponding entry of *H*(*s*)
has no zeros or poles.

Extract the measured and noise components of an identified polynomial model into two separate ZPK models. The former (measured component) can serve as a plant model while the latter can serve as a disturbance model for control system design.

load icEngine z = iddata(y,u,0.04); nb = 2; nf = 2; nc = 1; nd = 3; nk = 3; sys = bj(z, [nb nc nd nf nk]);

`sys` is a model of the form, `y(t)
= B/F u(t) + C/D e(t)`, where `B/F` represents
the measured component and `C/D` the noise component.

sysMeas = zpk(sys, 'measured')

Alternatively, use can simply use `zpk(sys)` to
extract the measured component.

sysNoise = zpk(sys, 'noise')

Was this topic helpful?