model object. For example, the estimation method n4sid is unique to the state-space model object idss. Every class has a special method for creating objects of that class, called the constructor. Using a constructor creates an instance of the corresponding class or instantiates the object. The constructor name is the same as the class name. For example, idpoly is both the name of the class representing linear black-box polynomial models and the name of the constructor for instantiating the model object. For a tutorial about estimating models at the command line, see Tutorial Identifying Linear Models Using the Command Line in System Identification Toolbox Getting Started Guide.
When to Construct a Model Structure Independently of Estimation
You use model constructors to create a model object at the command line by specifying all required model properties explicitly. You must construct the model object independently of estimation when you want to: Simulate a model Analyze a model Specify an initial guess for specific model parameter values before estimation In most cases, you can use the estimation commands to both construct and estimate the modelwithout having to construct the model object independently. For example, the estimation command pem lets you specify both the model structure with unknown parameters and the estimation algorithm. For information about how to both construct and estimate models with a single command, see Commands for Model Estimation on page 1-12. In case of grey-box models, you must always construct the model object first and then estimate the parameters of the ordinary differential or difference equation. For more information, see Chapter 5, ODE Parameter Estimation (Grey-Box Modeling).
Commands for Constructing Model Structures
The following table summarizes the model constructors available in the System Identification Toolbox product for representing various types of models. After model estimation, you can recognize the corresponding model objects in the MATLAB Workspace browser by their class names. The name of the constructor matches the name of the object it creates. For information about how to both construct and estimate models with a single command, see Commands for Model Estimation on page 1-12. Summary of Model Constructors Model Constructor
Resulting Model Class Parametric multiple-output ARX models. Also represents nonparametric transient-response models. Nonparametric frequency-response model. Continuous-time, low-order transfer functions (process models). Linear input-output polynomial models: ARX ARMAX Output-Error Box-Jenkins Linear state-space models.
Single or Multiple Outputs? Single- or multiple-output models.

idfrd idproc

Single- or multiple-output models. Single-output models only.

Note The input and output signals must have the same number of data samples. To import data into the GUI:
2 In the System Identification Tool window, select Import data > Freq.
Input Enter the MATLAB variable name (column vector or matrix) or a MATLAB expression that represents the input data. The expression must evaluate to a column vector or matrix. Output Enter the MATLAB variable name (column vector or matrix) or a MATLAB expression that represents the output data. The expression must evaluate to a column vector or matrix. Frequency Enter the MATLAB variable name of a vector or a MATLAB expression that represents the frequencies. The expression must evaluate to a column vector. The frequency vector must have the same number of rows as the input and output signals. Data name Enter the name of the data set, which appears in the System Identification Tool window after the import operation is completed. Frequency unit Enter Hz for Hertz or keep the rad/s default value. Sampling interval Enter the actual sampling interval in the experiment. For continuous-time data, enter 0. For more information about this setting, see Specifying the Data Sampling Interval on page 2-31.
box and enter the following optional settings: Input Properties InterSample This options specifies the behavior of the input signals between samples during data acquisition. It is used when transforming models from discrete-time to continuous-time and when resampling the data. zoh (zero-order hold) indicates that the input was piecewise-constant during data acquisition. foh (first-order hold) indicates that the output was piecewise-linear during data acquisition. bl (bandwidth-limited behavior) specifies that the continuous-time input signal has zero power above the Nyquist frequency (equal to the inverse of the sampling interval). Note See the d2c and c2d reference page for more information about transforming between discrete-time and continuous-time models. Period Enter Inf to specify a nonperiodic input. If the underlying time-domain data was periodic over an integer number of periods, enter the period of the input signal. Note If your data is periodic, always include a whole number of periods for model estimation. Channel Names Input Enter a string to specify the name of one or more input channels.
Tip Naming channels helps you to identify data in plots. For multivariable input and output signals, you can specify the names of individual Input and Output channels, separated by commas. Output Enter a string to specify the name of one or more output channels. Physical Units of Variables Input Enter a string to specify the input units. Tip When you have multiple inputs and outputs, enter a comma-separated list of Input and Output units corresponding to each channel. Output Enter a string to specify the output units. Notes Enter comments about the experiment or the data. For example, you might enter the experiment name, date, and a description of experimental conditions. Models you estimate from this data inherit your data notes.

Detrending Steady-State Data
Before you can perform this task, you must have time-domain data as an iddata object. See Representing Time- and Frequency-Domain Data Using iddata Objects on page 2-50. Note If you plan to estimate models from this data, your data must be regularly sampled. Use the detrend command to remove the signal means or linear trends:
[data_d,T]=detrend(data,Type)
where data is the data to be detrended. The second input argument Type=0 removes signal means or Type=1 removes linear trends. data_d is the detrended data. T is a TrendInfo object that stores the values of the subtracted offsets and slopes of the removed trends.
Detrending Transient Data
Before you can perform this task, you must have Time-domain data as an iddata object. See Representing Time- and Frequency-Domain Data Using iddata Objects on page 2-50. Note If you plan to estimate models from this data, your data must be regularly sampled. Values of the offsets you want to remove from the input and output data. If you do not know these values, visually inspect a time plot of your data. For more information, see How to Plot Data at the Command Line on page 2-86.
1 Create a default object for storing input-output offsets that you want to

remove from the data.

T = getTrend(data)
where T is a TrendInfo object.
2 Assign offset values to T.
T.InputOffset=I_value; T.OutputOffset=O_value;
where I_value is the input offset value, and O_value is the input offset value.
3 Remove the specified offsets from data.

data_d = detrend(data,T)

where the second input argument T stores the offset values as its properties.

detrend TrendInfo

Next Steps After Detrending
After detrending your data, you might do the following: Perform other data preprocessing operations. See Ways to Prepare Data for System Identification on page 2-5. Estimate a linear model. See Chapter 3, Linear Model Identification.

Resampling Data

In this section. What Is Resampling? on page 2-103 Resampling Data Using the GUI on page 2-104 Resampling Data at the Command Line on page 2-104 Resampling Data Without Aliasing Effects on page 2-106 See Also on page 2-109

Discrete-Time Representation
Discrete-time state-space models provide the same type of linear difference relationship between the inputs and the outputs as the linear ARX model, but are rearranged such that there is only one delay in the expressions. The discrete-time state-space model structure is often written in the innovations form that describes noise:
x(kT + T ) = Ax(kT ) + Bu(kT ) + Ke(kT ) y(kT ) = Cx(kT ) + Du(kT ) + e(kT ) x(0) = x0
where T is the sampling interval, u(kT) is the input at time instant kT, and y(kT) is the output at time instant kT. Note K=0 gives the state-space representation of an Output-Error model. For more information about Output-Error models, see What Are Black-Box Polynomial Models? on page 3-39.
Relationship Between Continuous-Time and Discrete-Time State Matrices
The relationships between the discrete state-space matrices A, B, C, D, and K and the continuous-time state-space matrices F, G, H, D, and K are given for piece-wise-constant input, as follows:

A = e FT

These relationships assume that the input is piece-wise-constant over time intervals kT t < (k + 1)T.
The exact relationship between K and K is complicated. However, for short sampling intervals T, the following approximation works well:
State-Space Representation of Transfer Functions
For linear models, the general symbolic model description is given by:
G is a transfer function that takes the input u to the output y. H is a transfer function that describes the properties of the additive output noise model. The discrete-time state-space representation is given by the following equation:
where T is the sampling interval, u(kT) is the input at time instant kT, and y(kT) is the output at time instant kT. The relationships between the transfer functions and the discrete-time state-space matrices are given by the following equations:
G(q) = C(qInx A)1 B + D H (q) = C(qInx A)1 K + Iny
where Inx is the nx-by-nx identity matrix, Iny is the nx-by-nx identity matrix, and ny is the dimension of y and e.
Data Supported by State-Space Models
Types of Supported Data on page 3-77 Estimating Continuous-Time Models on page 3-77 Designating Data for Estimating Discrete-Time Models on page 3-78
You can estimate linear state-space models from data with the following characteristics: Real data or complex data in any domain Single-output and multiple-output Time- or frequency-domain data To estimate state-space models for time-series data, see Chapter 6, Time Series Identification. You must first import your data into the MATLAB workspace, as described in Chapter 2, Data Import and Processing.

m = pem(data)

where data is your estimation data. This command estimates a state-space model for an automatically selected order between 1 and 10. To find a black-box model of a specific order n, use the following syntax:

m = pem(Data,n)

The iterative algorithm pem is initialized by the subspace method n4sid. You can use n4sid directly, as an alternative to pem:

m = n4sid(Data,n)

How to Estimate State-Space Models with Canonical Parameterization
What Is Canonical Parameterization? on page 3-92 Estimating Canonical State-Space Models on page 3-93
What Is Canonical Parameterization?
Canonical parameterization represents a state-space system in its minimal form, using the minimum number of free parameters to capture the dynamics. Thus, free parameters appear in only a few of the rows and columns in system matrices A, B, C, and D, and the remaining matrix elements are fixed to zeros and ones. Of the two popular canonical forms, which include controllable canonical form and observable canonical form, the toolbox supports only controllable
forms. Controllable canonical structures include free parameters in output rows of the A matrix, free B and K matrices, and the fixed C matrix. The representation within controllable canonical forms is not unique and the exact form depends on the actual choices of canonical indices. For more information about the distribution of free parameters in canonical forms, see the appendix on identifiability of black-box multivariable model structures in System Identification: Theory for the User, Second Edition, by Lennart Ljung, Prentice Hall PTR, 1999 (equation 4A.16).
Estimating Canonical State-Space Models
You can estimate state-space models with canonical parameterization at the command line. To specify a canonical form for A, B, C, and D, set the SSparameterization model property directly in the estimator syntax, as follows:
m = pem(data,n,'SSparameterization','canonical')
If you have time-domain data, the preceding command estimates a discrete-time model. Note When you estimate the D matrix in canonical form, you must set the nk property. See Choosing to Estimate D, K, and X0 Matrices on page 3-90. If you have continuous-time frequency-domain data, the preceding syntax estimates an nth order continuous-time state-space model with no direct contribution from the input to the output (D=0). To include a D matrix, set the nk property to 0 in the estimation, as follows:
m = pem(data,n,'SSparameterization','canonical', 'nk',0)
You can specify additional property-value pairs similar to the free-parameterization case, as described in How to Estimate Free-Parameterization State-Space Models on page 3-91. For information about validating your model, see Overview of Model Validation and Plots on page 8-2.

Thus, linear, parametric models represent input-output relationships for two kinds of input channels: measured inputs and (unmeasured) noise inputs. For example, consider the ARX model given by one of the following equations:
B(q) 1 u(t) + e(t) A(q) A(q)
In this case, the dynamic model is the relationship between the measured input u and output y, G = B( q) A( q). The noise model is the contribution of the input noise e to the output y, given by H = 1 A( q). Suppose that the model m contains both a dynamic model G and a noise model H. To create a new model by subreferencing G due to measured inputs, use the following syntax:

m_G = m('measured')

Tip Alternatively, you can use the following shorthand syntax: m_G = m('m')
To create a new model by subreferencing H due to unmeasured inputs, use the following syntax:

m_H = m('noise')

Tip Alternatively, you can use the following shorthand syntax: m_H = m('n') This operation creates a time-series model from m by ignoring the measured input. The covariance matrix of e is given by the idmodel property NoiseVariance, which is the matrix :

= LLT

The covariance matrix of e is related to v, as follows:
e = Lv where v is white noise with an identity covariance matrix representing independent noise sources with unit variances.
Treating Noise Channels as Measured Inputs
To study noise contributions in more detail, it might be useful to convert the noise channels to measured channels using noisecnv:

m_GH = noisecnv(m)

This operation creates a model m_GH that represents both measured inputs u and noise inputs e, treating both sources as measured signals. m_GH is a model from u and e to y, describing the transfer functions G and H.
Converting noise channels to measured inputs loses information about the variance of the innovations e. For example, step response due to the noise channels does not take into consideration the magnitude of the noise contributions. To include this variance information, normalize e such that v becomes white noise with an identity covariance matrix, where

e = Lv

To normalize e, use the following command:
m_GH = noisecnv(m,'Norm')

nonlinear functions. Simulation error minimization takes more time than one-step-ahead prediction error minimization. Common algorithm properties of idnlarx class. MaxIter Maximum number of iterations. SearchMethod Search method for minimization of prediction or simulation errors, such as Gauss-Newton and Levenburg-Marquardt line search, and Trust-region reflective Newton approach. By default, the algorithm uses a combination of these methods. Tolerance Condition for terminating iterative search when the expected improvement of the parameter values is less than a specified value. Display Shows progress of iterative minimization in the MATLAB Command Window.
How to Estimate Nonlinear ARX Models in the GUI
Prerequisites Learn about the nonlinear ARX model structure (see Structure of Nonlinear ARX Models on page 4-9). Import data into the System Identification Tool GUI (see Preparing Data for Nonlinear Identification on page 4-7). (Optional) Choose a nonlinearity estimator in Nonlinearity Estimators for Nonlinear ARX Models on page 4-10.
1 In the System Identification Tool GUI, select Estimate > Nonlinear
models to open the Nonlinear Models dialog box.
2 In the Configure tab, select Nonlinear ARX from the Model type list (if
it is not already selected).
3 (Optional) Edit the Model name by clicking the pencil icon. The name of
the model should be unique to all nonlinear ARX models in the System Identification Tool GUI.
4 (Optional) If you want to refine a previously estimated model, click
Initialize to select a previously estimated model from the Initial Model list. Note Refining a previously estimated model starts with the parameter values of the initial model and uses the same model structure. The algorithm uses default estimation settings unless you specify to use the initial model settings, or change these settings. The Initial Model list includes models that: Exist in the System Identification Tool GUI. Have the same number of inputs and outputs as the dimensions of the estimation data (selected as Working Data in the System Identification Tool GUI).
5 Keep the default settings in the Nonlinear Models dialog box that specify
the model structure and the algorithm, or modify these settings: Note For more information about available options, click Help in the Nonlinear Models dialog box to open the GUI help.

What to Configure

Options in Nonlinear Models GUI In the Regressors tab, edit the No. of Terms corresponding to each input and output channel. In the Regressors tab, edit the Delay corresponding to an input channel.

Comment

Model order
Model order na is the output No. of Terms, and nb is the input No. of Terms. If you do not know the input delay value, click Infer Input Delay. This action opens the Infer Input Delay

m = nlarx(data,[1]) % all standard regressors are % inputs to the nonlinear function
getreg(m) % lists all standard regressors m = nlarx(data,[1],sigmoidnet,'nlreg',[7 8])
This example uses getreg to determine the index of each regressor from the complete list of all model regressors. Only regressor numbers 5 through 8 are inputs to the nonlinear functiongetreg shows that these regressors are functions of the input variable u1. nlreg is an abbreviation for the NonlinearRegressors property of the idnlarx class. Alternatively, include only input regressors in the nonlinear function block using:
m = nlarx(data,[1],sigmoidnet,'nlreg','input')
When you are not sure which regressors to include as inputs to the nonlinear function block, specify to search during estimation for the optimum regressor combination:
m = nlarx(data,[1],sigmoidnet,'nlreg','search')
After estimation, use m.NonlinearRegressors to view which regressors were selected by the automatic regressor search. This search typically takes a long time, and you can display the search progress using:
m = nlarx(data,[1],sigmoidnet,'nlreg','search',. 'Display', 'on')
Configure the nonlinearity estimator. Specify the nonlinearity estimator directly in the estimation command as: A string of the nonlinearity name, which uses the default nonlinearity configuration.
m = nlarx(data, [1],'sigmoidnet')
m = nlarx(data,[1],'sig') % abbreviated string

Nonlinearity object.

m = nlarx(data,[1],wavenet('num',5))
This estimation uses a nonlinear ARX model with a wavelet nonlinearity that has 5 units. To construct the nonlinearity object before providing it as an input to the nonlinearity estimator:
w = wavenet('num', 5); m = nlarx(data,[1],w)
w = wavenet; w.NumberOfUnits = 5; m = nlarx(data,[1],w)
For MIMO systems, you can specify a different nonlinearity for each output. For example, to specify sigmoidnet for the first output and wavenet for the second output:
M = nlarx(data,[na nb nk],[sigmoidnet; wavenet])
If you want the same nonlinearity for all output channels, specify one nonlinearity. This table summarizes values that specify nonlinearity estimators. Nonlinearity Wavelet network (default) One layer sigmoid network Tree partition F is linear in x Value (Default Nonlinearity Configuration)

number of samples, and enter the number of samples to use for each regressor. Click Apply and then Close. For example, if the number of samples is 20, each regressor variable contains 20 points in its specified range. For a 3-D plots, this results in evaluating the nonlinearity at 20 x 20 = 400 points.
Axis Limits, Legend, and 3-D Rotation
The following table summarizes the commands to modify the appearance of the Nonlinear ARX plot.
Changing Appearance of the Nonlinear ARX Plot Action Change axis limits. Command Select Options > Set axis limits to open the Axis Limits dialog box, and edit the limits. Click Apply. Select Style > Legend. Select this option again to show the legend. Select Style > 3D Rotate and drag the axes on the plot to a new orientation. To disable three-dimensional rotation, select Style > 3D Rotate again.
Hide or show the legend. (Three axes only) Rotate in three dimensions. Note Available only when you have selected two regressors as independent variables.
Using Nonlinear ARX Models
Simulation and Prediction Use sim(idnlarx) to simulate the model output, and predict(idnlarx) to predict the model output. To compare models to measured output and to each other, use compare. Simulation and prediction commands provide default handling of the models initial conditions, or initial state values. See the idnlarx reference page for a definition of the nonlinear ARX model states. This toolbox provides several options to facilitate how you specify initial states. For example, you can use findstates(idnlarx) and data2state(idnlarx) to compute state values based on operating conditions or the requirement to maximize fit to measured output. To learn more about how sim and predict compute the model output, see Low-Level Manipulation of Nonlinear ARX Components on page 4-41.
Linearization Compute linear approximation of nonlinear ARX models using linearize(idnlarx) or linapp.
linearize provides a first-order Taylor series approximation of the system about an operation point (also called tangent linearization). linapp computes
a linear approximation of a nonlinear model for a given input data. For more information, see the Linear Approximation of Nonlinear Black-Box Models on page 4-81. You can compute the operating point for linearization using findop(idnlarx). After computing a linear approximation of a nonlinear model, you can perform linear analysis and control design on your model using Control System Toolbox commands. For more information, see Chapter 9, Control Design Applications. Simulation and Code Generation Using Simulink You can import estimated Nonlinear ARX models into Simulink software using the Nonlinear ARX block from the System Identification Toolbox block library. Import the idnlarx object from the workspace into Simulink using this block to simulate the model output. The Nonlinear ARX block supports code generation with Simulink Coder software, using both generic and embedded targets. Code generation does not work when the model contains customnet or neuralnet nonlinearity estimator, or custom regressors. For more information about working in the Simulink environment, see Chapter 10, System Identification Toolbox Blocks.

See Also: sim (for linear models), sim(idnlarx), sim(idnlgrey),

sim(idnlhw)

Prediction: Default initial conditions depend on the type of model. You can specify other initial conditions using the InitialState argument in predict. For example, to compute the initial states that optimize the 1-step-ahead predicted response of the model m to the output data z:
[Yp,X0est] = predict(m,z,1,'InitialState','Estimate')
This command returns the estimated initial states as the output argument X0est. For information about other ways to specify initials states, see the predict reference page for the corresponding model type. See Also: predict (for linear models), predict(idnlarx), predict(idnlgrey), predict(idnlhw)
Example Simulating Model Output with Noise at the Command Line
This example demonstrates how you can create input data and a model, and then use the data and the model to simulate output data. In this case, you use the following ARMAX model with Gaussian noise e:
y(t) 1.5 y(t 1) + 0.7 y(t 2) = u(t 1) + 0.5u(t 2) + e(t) e(t 1) + 0.2e(t 1)
Create the ARMAX model and simulate output data with random binary input u using the following commands:
% Create an ARMAX model m_armax = idpoly([1 -1.5 0.7],[0.5],[1 -1 0.2]); % Create a random binary input u = idinput(400,'rbs',[0 0.3]); % Simulate the output data y = sim(m_armax,u,'noise');
Note The argument 'noise' specifies to include in the simulation the Gaussian noise e present in the model. Omit this argument to simulate the noise-free response to the input u, which is equivalent to setting e to zero.
Example Simulating a Continuous-Time State-Space Model at the Command Line
This example demonstrates how to simulate a continuous-time state-space model using a random binary input u and a sampling interval of 0.1 s. Consider the following state-space model:
1 0.5 x= x + 0.5 u + 0.5 e 0. y = [1 0] x + e
where e is Gaussian white noise with variance 7.

What Does a Transient Response Plot Show?
Transient response plots show the value of the impulse or step response on the vertical axis. The horizontal axis is in units of time you specified for the data used to estimate the model. The impulse response of a dynamic model is the output signal that results when the input is an impulse. That is, u(t) is zero for all values of t except at t=0, where u(0)=1. In the following difference equation, you can compute the impulse response by setting y(-T)=y(-2T)=0, u(0)=1, and u(t>0)=0.
y(t) 1.5 y(t T ) + 0.7 y(t 2T ) = 0.9u(t) + 0.5u(t T )
The step response is the output signal that results from a step input, where u(t<0)=0 and u(t>0)=1. If your model includes a noise model, you can display the transient response of the noise model associated with each output channel. For more information about how to display the transient response of the noise model, see How to Plot Impulse and Step Response Using the GUI on page 8-32. The following figure shows a sample Transient Response plot, created in the System Identification Tool GUI.
How to Plot Impulse and Step Response Using the GUI
To create a transient analysis plot in the System Identification Tool GUI, select the Transient resp check box in the Model Views area. For general information about creating and working with plots, see Working with Plots in the System Identification Tool GUI on page 11-15. To include or exclude a model on the plot, click the corresponding model icon in the System Identification Tool GUI. Active models display a thick line inside the Model Board icon. The following table summarizes the Transient Response plot settings.
Transient Response Plot Settings Action Display step response for linear or nonlinear model. Display impulse response for linear model. Command Select Options > Step response. Select Options > Impulse response. Note Not available for nonlinear models. Display the confidence interval. Note Only available for linear models. To display the dashed lines on either side of the nominal model curve, select Options > Show confidence intervals. Select this option again to hide the confidence intervals. To change the confidence value, select Options > Set % confidence level, and choose a value from the list. To enter your own confidence level, select Options > Set confidence level > Other. Enter the value as a probability (between 0 and 1) or as the number of standard deviations of a Gaussian distribution. Change time span over which the impulse or step response is calculated. For a scalar time span T, the resulting response is plotted from -T/4 to T. Select Options > Time span (time units), and choose a new time span in units of time you specified for the model.

Troubleshooting Models

In this section. About Troubleshooting Models on page 8-64 Model Order Is Too High or Too Low on page 8-64 Nonlinearity Estimator Produces a Poor Fit on page 8-65 Substantial Noise in the System on page 8-66 Unstable Models on page 8-66 Missing Input Variables on page 8-68 Complicated Nonlinearities on page 8-68
About Troubleshooting Models
During validation, you might find that your model output fits the validation data poorly. You might also find some unexpected or undesirable model characteristics. If the tips suggested in these sections do not help improve your models, then a good model might not be possible for this data. For example, your data might have poor signal-to-noise ratio, large and nonstationary disturbances, or varying system properties.
Model Order Is Too High or Too Low
When the Model Output plot does not show a good fit, there is a good chance that you need to try a different model order. System identification is largely a trial-and-error process when selecting model structure and model order. Ideally, you want the lowest-order model that adequately captures the system dynamics. You can estimate the model order as described in Preliminary Step Estimating Model Orders and Input Delays on page 3-48. Typically, you use the suggested order as a starting point to estimate the lowest possible order with different model structures. After each estimation, you monitor the Model Output and the Residual Analysis plots, and then adjust your settings for the next estimation.
When a low-order model fits the validation data poorly, try estimating a higher-order model to see if the fit improves. For example, if a Model Output plot shows that a fourth-order model gives poor results, try estimating an eighth-order model. When a higher-order model improves the fit, you can conclude that higher-order models might be required and linear models might be sufficient. You should use an independent data set to validate your models. If you use the same data set to both estimate and validate a model, the fit always improves as you increase model order, and you risk overfitting. However, if you use an independent data set to validate your models, the fit eventually deteriorates if your model orders are too high. High-order models are more expensive to compute and result in greater parameter uncertainty.
Nonlinearity Estimator Produces a Poor Fit
In the case of nonlinear ARX and Hammerstein-Wiener models, the Model Output plot does not show a good fit when the nonlinearity estimator has incorrect complexity. You specify the complexity of piece-wise-linear, wavelet, sigmoid, and custom networks using the number of units (NumberOfUnits nonlinear estimator property). A high number of units indicates a complex nonlinearity estimator. In the case of neural networks, you specify the complexity using the parameters of the network object. For more information, see the Neural Network Toolbox documentation. To select the appropriate complexity of the nonlinearity estimator, start with a low complexity and validate the model output. Next, increate the complexity and validate the model output again. The model fit degrades when the nonlinearity estimator becomes too complex. Note To see the model fit degrade when the nonlinearity estimator becomes too complex, you must use an independent data set to validate the data that is different from the estimation data set.

data, convert the model to idss object, and then specify its initial states as described previously. For example, for the following idpoly model:

m1=idpoly([1],[2 2]);

the initial states correspond to those of the equivalent state-space model:

m2=idss(m1);

For more information about specifying initial conditions for simulation, see the IDMODEL Model reference page.
Specifying Initial States of Nonlinear ARX Models
The states of a nonlinear ARX model correspond to the dynamic elements of the nonlinear ARX model structure, which are the model regressors. Regressors can be the delayed input/output variables (standard regressors) or user-defined transformations of delayed input/output variables (custom regressors). For more information about the states of a nonlinear ARX model, see the idnlarx reference page. For simulating nonlinear ARX models, you can specify the initial conditions as input/output values, or as a vector. For more information about specifying initial conditions for simulation, see the IDNLARX Model reference page.
Specifying Initial States of Hammerstein-Wiener Models
The states of a Hammerstein-Wiener model correspond to the states of the embedded linear (idpoly or idss) model. For more information about the states of a Hammerstein-Wiener model, see the idnlhw reference page. The default initial state for simulating a Hammerstein-Wiener model is 0. For more information about specifying initial conditions for simulation, see the IDNLHW Model reference page.
Example Simulating a Model Using Simulink Software
In this example, you set the initial states for simulating a model such that the simulation provides a best fit to measured input-output data. Prerequisites Estimate a three-state model M using a multiple-experiment data set Z, which contains data from three experiments z1, z2, and z3:
% Load multi-experiment data. load(fullfile(matlabroot, 'toolbox', 'ident', 'iddemos',. 'data', 'twobodiesdata')); % Create an iddata object to store the multi-experiment data. z1=iddata(y1, u1, 0.005,'Tstart',0); z2=iddata(y2, u2, 0.005,'Tstart',0); z3=iddata(y3, u3, 0.005,'Tstart',0); Z = merge(z1,z2,z3); % Estimate a 5th order state-space model. M = n4sid(Z,5,'Focus','Simulation');
When you estimate a model using multiple data sets, the initial-states property, X0, of the model, M, stores only the estimated states corresponding to the last data set. In this example: Values of M.X0 are the estimated state values, corresponding to the last experiment in Z. M.X0 is a vector of length 5, corresponding to the five states of the model. To compute initial states that maximizes the fit to the corresponding output

System Identification Toolbox 7
Create linear and nonlinear dynamic models from measured input-output data
System Identification Toolbox lets you construct mathematical models of dynamic systems from measured input-output data. This data-driven approach helps you describe systems that are not easily modeled from first principles or specifications, such as chemical processes and engine dynamics. It also helps you simplify detailed first-principle models, such as finite-element models of structures and flight dynamics models, by fitting simpler models to their simulated responses. Models obtained with System Identification Toolbox are well suited for simulation, prediction, and control system design using products such as Simulink, Control System Toolbox, and Model Predictive Control Toolbox (all available separately). System Identification Toolbox lets you fit linear and nonlinear models to data, a process known as black-box modeling. Available model structures include loworder process models, transfer functions, state-space models, linear models with static nonlinearities at the inputs or outputs, and nonlinear autoregressive models. If you have a mathematical model of the system dynamics, you can tune its parameters to better match experimental data, a process known as grey-box modeling. The principal architect of the toolbox is Professor Lennart Ljung, a recognized leader in the field of system identification.

Key features

dentifies linear and nonlinear models from time- and I frequency-domain data Simplifies identification of first-, second-, and third-order continuous-time models nalyzes measured data and advises on data quality, required A preprocessing, and presence of feedback or nonlinearities rovides data processing tools for detrending, filtering, and P reconstructing missing data Provides Simulink blocks for simulating identified models and transferring data to and from the MATLAB workspace Provides an interface for using linear models in Control System Toolbox (available separately)
Using System Identification Toolbox with Simulink. The toolbox provides blocks that let you bring identified models into Simulink.
Accelerating the pace of engineering and science
Working with System Identification Toolbox
System Identification Toolbox facilitates the multistep process of identifying models from data. The toolbox enables you to: Analyze and process data Determine suitable model structure and order Estimate model parameters and validate model accuracy View the model responses and their uncertainties
You can perform these tasks by using either command-line functions or a graphical user interface (GUI). You can convert the models into linear timeinvariant (LTI) objects for use with Control System Toolbox. You can incorporate most identified models into Simulink models using blocks provided by the toolbox.
The toolbox lets you attach this information to the data using data objects. The data objects facilitate easy visualization of data, domain conversion, and various preprocessing tasks. Measured data often has offsets, slow drifts, outliers, missing values, and other anomalies. The toolbox removes such anomalies by performing operations such as detrending, filtering, resampling, and reconstruction of missing data. The toolbox can analyze the suitability of data for identification and provide diagnostics regarding persistence of excitation, existence of feedback loops, intersample behavior, and presence of nonlinearities.
Working with Measured Data
When preparing data for identification of models, you need to specify information such as input-output channel names, sampling interval, and intersample behavior.

Deriving models from data. You can use the System Identification Toolbox GUI (right) to analyze and preprocess data (below, left), estimate linear and nonlinear models (below, middle), and validate estimated models (below, right).
Data analysis and preprocessing. You can analyze time- and frequency-domain data and perform preprocessing tasks, such as filtering and detrending.
The toolbox produces estimates of step and frequency responses of the system directly from measured data. Using these responses, you can analyze system characteristics, such as time constants, input delays, and resonant frequencies. You can use this information to configure the parametric models during estimation.
Output-Error (OE) models, and state-space parameterizations. Estimation techniques include maximum likelihood, predictionerror minimization schemes, and such subspace methods as CVA, MOESP, and N4SID. You can also estimate a model of the noise affecting the observed system. In cases where you only need a low-order continuous-time model, the toolbox provides special capabilities to simplify the estimation process and obtain results quickly. These models are expressed as simple transfer functions involving three or fewer poles, and optionally, a zero, a timedelay, or an integrator.
Estimating Parametric Models
Parametric models, such as transfer functions or state-space models, use a small number of parameters to capture system dynamics. The toolbox estimates model parameters and their uncertainties. You can analyze these models, or their linear equivalents, using time- and frequency-response plots such as step, impulse, bode plots, and pole-zero maps.
Toolbox, available separately). Using Hammerstein-Wiener models, you can estimate static nonlinear distortions present at the input and/or output of an otherwise linear system. For example, you can estimate the saturation levels affecting the input current into a DC motor, or capture a complex nonlinearity at the output using a piecewise linear nonlinearity.
Estimating Parameters in User-Defined Models
A user-defined (grey-box) model is a set of differential or difference equations with some unknown parameters. The toolbox lets you specify the model structure and estimate its parameters using nonlinear optimization techniques. For linear models, you can explicitly specify the structure of state-space matrices and impose constraints on identified parameters. For nonlinear models, you can specify differential equations as M, C, or FORTRAN code.

Estimating Nonlinear Black-Box Models
When linear models are not sufficient to capture system dynamics, you can estimate nonlinear models, such as nonlinear ARX and Hammerstein-Wiener models. Nonlinear ARX models enable you to model nonlinearities using wavelet networks, tree-partitioning, sigmoid networks, and neural networks (with Neural Network
Estimating Linear Black-Box Models
You can identify polynomial and statespace models using various estimation routines offered by the toolbox. These routines include autoregressive models (ARX, ARMAX), Box-Jenkins (BJ) models,

www.mathworks.com

Analyzing and validating estimated models. You can validate estimated models against test data, view time- and frequency-domain responses, and explore the shape of estimated nonlinearities.

Validating Results

System Identification Toolbox helps validate the accuracy of identified models using independent sets of measured data from a real system. For a given set of input data, you can compare simulated output of the identified model with the measured output from the real system. You can also view the prediction error and produce time- and frequency-response plots with confidence bounds to visualize the effect of parameter uncertainties on model responses.

Required Products

MATLAB

Related Products

Simulink. Simulation and Model-Based Design Control System Toolbox. Design and analyze control systems Neural Network Toolbox. Design and simulate neural networks Signal Processing Toolbox. Perform signal processing, analysis, and algorithm development Simulink Parameter Estimation. Estimate model parameters using test data For a complete list of related products, visit www.mathworks.com/products/sysid

Resources

visit www.mathworks.com Technical Support www.mathworks.com/support Online User Community www.mathworks.com/matlabcentral Demos www.mathworks.com/demos Training Services www.mathworks.com/training Third-Party Products and Services www.mathworks.com/connections Worldwide CONTACTS www.mathworks.com/contact e-mail info@mathworks.com
Platform and System Requirements
For platform and system requirements, visit www.mathworks.com/products/sysid
2007 MATLAB, Simulink, Stateflow, Handle Graphics, Real-Time Workshop, and xPC TargetBox are registered trademarks and SimBiology, SimEvents, and SimHydraulics are trademarks of The MathWorks, Inc. Other product or brand names are trademarks or registered trademarks of their respective holders.

8000v06 03/07