Continuoustime process model with identifiable parameters
sys = idproc(type)
sys = idproc(type,Name,Value)
creates
a continuoustime process model with identifiable parameters. sys
= idproc(type
)type
specifies
aspects of the model structures, such as the number of poles in the
model, whether the model includes an integrator, and whether the model
includes a time delay.
creates
a process model with additional attributes specified by one or more sys
= idproc(type
,Name,Value
)Name,Value
pair
arguments.
An idproc
model represents a system as
a continuoustime process model with identifiable (estimable) coefficients.
A simple SISO process model has a gain, a time constant, and a delay:
$$sys=\frac{{K}_{p}}{1+{T}_{p1}s}{e}^{{T}_{d}s}.$$
K_{p} is a proportional gain. T_{p}_{1} is the time constant of the real pole, and T_{d} is the transport delay (dead time).
More generally, idproc
can represent process
models with up to three poles and a zero:
$$sys={K}_{p}\frac{1+{T}_{z}s}{\left(1+{T}_{p1}s\right)\left(1+{T}_{p2}s\right)\left(1+{T}_{p3}s\right)}{e}^{{T}_{d}s}.$$
Two of the poles can be a complex conjugate (underdamped) pair. In that case, the general form of the process model is:
$$sys={K}_{p}\frac{1+{T}_{z}s}{\left(1+2\zeta {T}_{\omega}s+{\left({T}_{\omega}s\right)}^{2}\right)\left(1+{T}_{p3}s\right)}{e}^{{T}_{d}s}.$$
T_{ω} is the time constant of the complex pair of poles, and ζ is the associated damping constant.
In addition, any idproc
model can have an
integrator. For example, the following is a process model that you
can represent with idproc
:
$$sys={K}_{p}\frac{1}{s\left(1+2\zeta {T}_{\omega}s+{\left({T}_{\omega}s\right)}^{2}\right)}{e}^{{T}_{d}s}.$$
This model has no zero (T_{z} = 0). The model has a complex pair of poles. The model also has an integrator, represented by the 1/s term.
For idproc
models, all the time constants,
the delay, the proportional gain, and the damping coefficient can
be estimable parameters. The idproc
model stores
the values of these parameters in properties of the model such as Kp
, Tp1
,
and Zeta
. (See Properties for more information.)
A MIMO process model contains a SISO process model corresponding
to each inputoutput pair in the system. For idproc
models,
the form of each inputoutput pair can be independently specified.
For example, a twoinput, oneoutput process can have one channel
with two poles and no zero, and another channel with a zero, a pole,
and an integrator. All the coefficients are independently estimable
parameters.
There are two ways to obtain an idproc
model:
Estimate the idproc
model based
on output or inputoutput measurements of a system, using the procest
command. procest
estimates
the values of the free parameters such as gain, time constants, and
time delay. The estimated values are stored as properties of the resulting idproc
model.
For example, the properties sys.Tz
and sys.Kp
of
an idproc
model sys
store the
zero time constant and the proportional gain, respectively. (See Properties for more information.) The Report
property
of the resulting model stores information about the estimation, such
as handling of initial conditions and options used in estimation.
When you obtain an idproc
model by estimation,
you can extract estimated coefficients and their uncertainties from
the model using commands such as getpar
and getcov
.
Create an idproc
model using
the idproc
command.
You can create an idproc
model to configure
an initial parameterization for estimation of a process model. When
you do so, you can specify constraints on the parameters. For example,
you can fix the values of some coefficients, or specify minimum or
maximum values for the free coefficients. You can then use the configured
model as an input argument to procest
to
estimate parameter values with those constraints.

Model structure, specified as a character vector or cell array of character vectors. For SISO models,
Every
The values of all parameters in a particular model structure
are initialized to For a MIMO process model with 
Specify optional
commaseparated pairs of Name,Value
arguments. Name
is
the argument name and Value
is the corresponding value.
Name
must appear inside quotes. You can specify several name and value
pair arguments in any order as
Name1,Value1,...,NameN,ValueN
.
Use Name,Value
arguments to specify parameter
initial values and additional properties of idproc
models
during model creation. For example, sys = idproc('p2z','InputName','Voltage','Kp',10,'Tz',0);
creates
an idproc
model with the InputName
property
set to Voltage
. The command also initializes the
parameter Kp
to a value of 10, and Tz
to
0.
idproc
object properties include:

Model structure, specified as a character vector or cell array of character vectors. For a SISO model For a MIMO model with The character vectors are made up of one or more of the following characters that specify aspects of the model structure:
If you create an If you obtain an In general, you cannot change the type of an existing model.
However, you can change whether the model contains an integrator using
the property  

Values of process model parameters. If you create an For a MIMO model with For an Default: For each parameter value,  

Logical value or matrix denoting the presence or absence of an integrator in the transfer function of the process model. For a SISO model For a MIMO model, When you create a process model using the  

Coefficients of the noise transfer function.
Typically, the noise transfer function is automatically computed
by the estimation function NoiseNum = {[1 2.2]; [1 0.54]}; NoiseDen = {[1 1.3]; [1 2]}; NoiseTF = struct('num', {NoiseNum}, 'den', {NoiseDen}); sys = idproc({'p2'; 'p1di'}); % 2output, 1input process model sys.NoiseTF = NoiseTF; Each vector in Default:  

Information about the estimable parameters of the
Each of these parameter entries in
For a MIMO model with  

The variance (covariance matrix) of the model innovations e. An identified model includes a white, Gaussian noise component e(t). For SISO models,  

Summary report that contains information about the estimation
options and results when the process model is obtained using the
The contents of m = idproc('P2DU');
m.Report.OptionsUsed ans = [] If you obtain the process model using estimation commands, the
fields of load iddata2 z2; m = procest(z2,'P2DU'); m.Report.OptionsUsed DisturbanceModel: 'estimate' InitialCondition: 'auto' Focus: 'prediction' EstimateCovariance: 1 Display: 'off' InputOffset: [1x1 param.Continuous] OutputOffset: [] Regularization: [1x1 struct] SearchMethod: 'auto' SearchOptions: [1x1 idoptions.search.identsolver] OutputWeight: [] Advanced: [1x1 struct]
For more information on this property and how to use it, see the Output Arguments section of the corresponding estimation command reference page and Estimation Report.  

Input delays. For a system with Default: 0 for all input channels  

Output delays. For identified systems, like  

Sample time. For  

Units for the time variable, the sample time
Changing this property has no effect on other properties, and
therefore changes the overall system behavior. Use Default:  

Input channel names, specified as one of the following:
Alternatively, use automatic vector expansion to assign input
names for multiinput models. For example, if sys.InputName = 'controls'; The input names automatically expand to When you estimate a model using an You can use the shorthand notation Input channel names have several uses, including:
Default:  

Input channel units, specified as one of the following:
Use Default:  

Input channel groups. The sys.InputGroup.controls = [1 2]; sys.InputGroup.noise = [3 5]; creates input groups named sys(:,'controls') Default: Struct with no fields  

Output channel names, specified as one of the following:
Alternatively, use automatic vector expansion to assign output
names for multioutput models. For example, if sys.OutputName = 'measurements'; The output names automatically expand to When you estimate a model using an You can use the shorthand notation Output channel names have several uses, including:
Default:  

Output channel units, specified as one of the following:
Use Default:  

Output channel groups. The sys.OutputGroup.temperature = [1]; sys.InputGroup.measurement = [3 5]; creates output groups named sys('measurement',:) Default: Struct with no fields  

System name, specified as a character vector. For example, Default:  

Any text that you want to associate with the system, stored as a string or a cell array of
character vectors. The property stores whichever data type you
provide. For instance, if sys1.Notes = "sys1 has a string."; sys2.Notes = 'sys2 has a character vector.'; sys1.Notes sys2.Notes ans = "sys1 has a string." ans = 'sys2 has a character vector.' Default:  

Any type of data you want to associate with system, specified as any MATLAB^{®} data type. Default:  

Sampling grid for model arrays, specified as a data structure. For arrays of identified linear (IDLTI) models that are derived by sampling one or more independent variables, this property tracks the variable values associated with each model. This information appears when you display or plot the model array. Use this information to trace results back to the independent variables. Set the field names of the data structure to the names of the sampling variables. Set the field values to the sampled variable values associated with each model in the array. All sampling variables should be numeric and scalar valued, and all arrays of sampled values should match the dimensions of the model array. For example, if you collect data at various operating points of a system, you can identify a model for each operating point separately and then stack the results together into a single system array. You can tag the individual models in the array with information regarding the operating point: nominal_engine_rpm = [1000 5000 10000];
sys.SamplingGrid = struct('rpm', nominal_engine_rpm) where For model arrays generated by linearizing a Simulink^{®} model
at multiple parameter values or operating points, the software populates Default: 