Note: This page has been translated by MathWorks. Click here to see

To view all translated materials including this page, select Country from the country navigator on the bottom of this page.

To view all translated materials including this page, select Country from the country navigator on the bottom of this page.

This topic describes how the software evaluates the output of nonlinearity estimators and uses this output to compute the response of a Hammerstein-Wiener model.

Evaluating the output of a nonlinearity for a input *u* requires
that you first extract the input or output nonlinearity from the model:

F = M.InputNonlinearity; H = M.OutputNonlinearity;

Evaluate *F*(*u*):

w = evaluate(F,u)

where `u`

is a scalar representing the value
of the input signal at a given time.

You can evaluate output at multiple time instants by evaluating *F* for
several time values simultaneously using a column vector of input
values:

w = evaluate(F,[u1;u2;u3])

Similarly, you can evaluate the value of the nonlinearity *H* using
the output of the linear block *x*(*t*)
as its input:

y = evaluate(H,x)

For MIMO models, *F* and *H* are
vectors of length *nu* and *ny*,
respectively. *nu* is the number of inputs and *ny* is
the number of outputs. In this case, you must evaluate the predicted
output of each nonlinearity separately.

For example, suppose that you estimate a two-input model:

`M = nlhw(data,[nb nf nk],[wavenet;poly1d],'saturation')`

In the input nonlinearity:

F = M.InputNonlinearity F1 = F(1); F2 = F(2);

`F`

is a vector function containing two elements: `F=[F1(u1_value);F2(u2_value)]`

,
where `F1`

is a `wavenet`

object
and `F2`

is a `poly1d`

object. `u1_value`

is
the first input signal and `u2_value`

is the second
input signal.

Evaluate `F`

by evaluating `F1`

and `F2`

separately:

w1 = evaluate(F(1),u1_value); w2 = evaluate(F(2),u2_value);

The total input to the linear block, `w`

, is
a vector of `w1`

and `w2`

(```
w
= [w1 w2]
```

).

Similarly, you can evaluate the value of the nonlinearity *H*:

H = M.OutputNonlinearity;

This example shows how the software evaluates the simulated output by first computing the output of the input and output nonlinearity estimators.

Estimate a Hammerstein-Wiener model.

load twotankdata estData = iddata(y,u,0.2); M = nlhw(estData,[1 5 3],'pwlinear','poly1d');

Extract the input nonlinearity, linear model, and output nonlinearity as separate variables.

uNL = M.InputNonlinearity; linModel = M.LinearModel; yNL = M.OutputNonlinearity;

Simulate the output of the input nonlinearity estimator.

Input data for simulation

u = estData.u;

Compute output of input nonlinearity

w = evaluate(uNL,u);

Compute response of linear model to input `w`

and zero initial conditions.

x = sim(linModel,w);

Compute the output of the Hammerstein-Wiener model `M`

as the output of the output nonlinearity estimator to input `x`

.

y = evaluate(yNL,x);

The previous set of commands are equivalent to directly simulating the output of `M`

using the `sim`

command.

ysim = sim(M,u);

Plot `y`

and `ysim`

, the manual and direct simulation results, respectively.

time = estData.SamplingInstants; plot(time,y,'b',time,ysim,'--r'); xlabel('Time'); ylabel('Simulated Output')

The plot indicates that `y`

and `ysim`

are the same.