Estimate statespace model using time or frequency domain data
sys = ssest(data,nx)
sys = ssest(data,nx,Name,Value)
sys = ssest(___,opt)
sys = ssest(data,init_sys)
sys = ssest(data,init_sys,Name,Value)
sys = ssest(___,opt)
[sys,x0] = ssest(___)
estimates
a statespace model, sys
= ssest(data
,nx
)sys
,
using time or frequencydomain data, data
. sys
is a statespace model of order nx
and
represents:
$$\begin{array}{l}\dot{x}(t)=Ax(t)+Bu(t)+Ke(t)\\ y(t)=Cx(t)+Du(t)+e(t)\end{array}$$
A, B, C, D,
and K are statespace matrices. u(t)
is the input, y(t) is the output, e(t)
is the disturbance and x(t)
is the vector of nx
states.
All the entries of A, B, C,
and K are free estimable parameters by default. D is
fixed to zero by default, meaning that there is no feedthrough, except
for static systems (nx=0
).
estimates
the model using the additional options specified by one or more sys
= ssest(data
,nx
,Name,Value
)Name,Value
pair
arguments. Use the Form
, Feedthrough
and DisturbanceModel
namevalue
pair arguments to modify the default behavior of the A, B, C, D,
and K matrices.
estimates the model using an option set, sys
= ssest(___,opt
)opt
,
that specifies options such as estimation objective, handling of initial
conditions and numerical search method used for estimation.
estimates
a statespace model using the dynamic system sys
= ssest(data
,init_sys
)init_sys
to
configure the initial parameterization.
estimates
the model using additional options specified by one or more sys
= ssest(data
,init_sys
,Name,Value
)Name,Value
pair
arguments.
estimates the model using an option set, sys
= ssest(___,opt
)opt
.

Identified statespace model.


Initial states computed during the estimation. If This value is also stored in the 
Estimate a statespace model for measured inputoutput data. Determine the optimal model order within a given range.
Obtain measured inputoutput data.
load icEngine.mat;
data = iddata(y,u,0.04);
data
is an iddata
object
containing 1500 inputoutput data samples. The data sample time is
0.04 seconds.
Estimate a statespace model for measured inputoutput data. Determine the optimal model order within a given model order range.
nx = 1:10; sys = ssest(data,nx);
A plot that shows the Hankel singular values (SVD) for models
of the orders specified by nx
appears.
States with relatively small Hankel singular values can be safely
discarded. The default order choice is 3
.
Select the model order in the Model Order dropdown list and click Apply.
Identify a statespace model containing an input delay for given data.
Load timedomain system response data, and use it to identify a statespace model for the system. Specify a known input delay for the model.
load iddata7 z7 nx = 4; sys = ssest(z7(1:300),nx,'InputDelay',[2;0])
z7
is an iddata
object
that contains time domain system response data.
nx
specifies a fourthorder identified statespace
model.
The namevalue input argument pair 'InputDelay',[2;0]
specifies
an input delay of 2 seconds for the first input and 0 seconds for
the second output.
sys
is an idss
model containing
the identified statespace model.
Obtain a regularized 15th order statespace model for a 2nd order system from a narrow bandwidth signal.
Load data.
load regularizationExampleData eData;
Estimate an unregularized statespace model.
trueSys = idtf([0.02008 0.04017 0.02008],[1 1.561 0.6414],1); m = ssest(eData, 15, 'form', 'modal', 'DisturbanceModel', 'none');
Estimate a regularized statespace model.
opt = ssestOptions; opt.Regularization.Lambda = 9.7; mr = ssest(eData, 15, 'form','modal','DisturbanceModel','none', opt);
Compare the model outputs with data.
compare(eData,m,mr);
Compare the impulse responses of the models.
impulse(trueSys, m, mr, 50);
Identify a 15th order statespace model using regularized impulse response estimation.
Load data.
load regularizationExampleData eData;
Create a transfer function model used for generating the estimation data (true system).
trueSys = idtf([0.02008 0.04017 0.02008],[1 1.561 0.6414],1);
Obtain regularized impulse response (FIR) model.
opt = impulseestOptions('RegulKernel', 'DC'); m0 = impulseest(eData, 70, opt);
Convert the model into a transfer function model after reducing the order.
m = balred(idss(m0),15);
Obtain a statespace model using regularized reduction of ARX model.
m1 = ssregest(eData,15);
Compare the impulse responses of the true system, regularized and statespace models.
impulse(trueSys, m, m1, 50);
Estimate a statespace model using measured inputoutput data. Configure the parameter constraints and initial values for estimation using a statespace model.
Create an idss
model to specify the
initial parameterization for estimation.
Configure an idss
model so that it has no
statedisturbance element and only the nonzero entries of the A matrix
are estimable. Additionally, fix the values of the B matrix.
A = blkdiag([0.1 0.4; 0.4 0.1],[1 5; 5 1]); B = [1; zeros(3,1)]; C = [1 1 1 1]; D = 0; K = zeros(4,1); x0 = [0.1,0.1,0.1,0.1]; Ts = 0; init_sys = idss(A,B,C,D,K,x0,Ts);
Setting all entries of K = 0
creates an idss
model
with no state disturbance element.
Use the Structure
property of init_sys
to
fix the values of some of the parameters.
init_sys.Structure.a.Free = (A~=0); init_sys.Structure.b.Free = false; init_sys.Structure.k.Free = false;
The entries in init_sys.Structure.a.Free
determine
whether the corresponding entries in init_sys.a
are
free (identifiable) or fixed. The first line sets init_sys.Structure.a.Free
to
a matrix that is true
wherever A
is
nonzero, and false
everywhere else. Doing so fixes
the value of the zero entries in init_sys.a
.
The remaining lines fix all the values in init_sys.b
and init_sys.k
to
the values you specified when you created the model.
Load the measured data and estimate a statespace model
using the parameter constraints and initial values specified by init_sys
.
load iddata2 z2; sys = ssest(z2,init_sys);
sys
is an idss
model that
encapsulates the fourthorder, statespace model estimated for the
measured data z2
. The estimated parameters of sys
successfully
satisfy the constraints specified by init_sys
.
Reduce the order of a model by estimation.
Consider the Simulink model idF14Model
. Linearizing this model gives a ninthorder model. However, the dynamics of the model can be captured, without compromising the fit quality too much, using a lowerorder model.
Obtain the linearized model.
load_system('idF14Model'); io = getlinio('idF14Model'); sys_lin = linearize('idF14Model',io);
sys_lin
is a ninthorder statespace model with two outputs and one input.
Simulate the step response of the linearized model, and use the data to create an iddata
object.
Ts = 0.0444; t = (0:Ts:4.44)'; y = step(sys_lin,t); data = iddata([zeros(20,2);y],[zeros(20,1); ones(101,1)],Ts);
data
is an iddata
object that encapsulates the step response of sys_lin
.
Compare the data to the model linearization.
compare(data, sys_lin);
Because the data was obtained by simulating the linearized model, there is a 100% match between the data and model linearization response.
Identify a statespace model with a reduced order that adequately fits the data.
Determine an optimal model order.
nx = 1:9; sys1 = ssest(data,nx,'DisturbanceModel','none');
A plot showing the Hankel singular values (SVD) for models of
the orders specified by nx
appears.
States with relatively small Hankel singular values can be safely discarded. The plot suggests using a fifthorder model.
At the MATLAB^{®} command prompt, select the model order for
the estimated statespace model. Specify the model order as 5
,
or press Enter to use the default order value.
Compare the data to the estimated model.
compare(data, sys1);
sys1
provides a 98.4% fit for the first output and a 97.7% fit for the second output.
Examine the stopping condition for the search algorithm.
sys1.Report.Termination.WhyStop
ans = Maximum number of iterations reached
Create an estimation options set that specifies the 'lm'
search method and allows a maximum of 50 search iterations.
opt = ssestOptions('SearchMethod','lm'); opt.SearchOption.MaxIter = 50; opt.Display = 'on';
Identify a statespace model using the estimation option set and sys1
as the estimation initialization model.
sys2 = ssest(data, sys1, opt);
Compare the response of the linearized and the estimated models.
compare(data,sys_lin,sys2);
sys2
provides a 99% fit for the first output and a 98% fit for the second output while using 4 less states than sys_lin
.
[1] Ljung, L. System Identification: Theory For the User, Second Edition, Upper Saddle River, N.J: Prentice Hall, 1999.