# idproc

Continuous-time process model with identifiable parameters

## Description

An `idproc`

model represents a system as a continuous-time
process model with estimable coefficients. Use `idproc`

to create a process
model.

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*is the transport delay (dead time).

_{d}More generally, `idproc`

can represent process models with up to three
poles and one 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) and 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 input/output pair
in the system. For `idproc`

models, the form of each input/output pair can be
independently specified. For example, a two-input, one-output 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.

## Creation

There are two ways to obtain an `idproc`

model:

Estimate the

`idproc`

model based on input/output 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. The`Report`

property of the resulting model stores information about the estimation, such as handling of initial conditions and options used in estimation. For example, you can use the following commands to estimate and get information about a first-order process model.For more information about`sys = procest(data,"P1"); kp = sys.Kp sys.Report`

`idproc`

properties, see Properties.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. For example, fix the value of`Tp1`

to`1`

and constrain the value of`Kp1`

to a range of`[0.3 0.6]`

.For more information about configuring and using an initial parameterization, seeinit_sys.Structure.Tp1 = 1; init_sys.Structure.Tp1.Free = False; init_sys.Structure.Kp1.Min = 0.3; init_sys.Structure.Kp1.Max = 0.6; sys = procest(data,init_sys)

`procest`

.

For information on functions you can use to extract information from or transform
`idproc`

model objects, see Object Functions.

### Description

creates a continuous-time
process model with estimable parameters and sets the `sys`

= idproc(Type)`Type`

property. `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 properties specified by one or more name-value
arguments.`sys`

= idproc(Type,`Name,Value`

)

## Properties

## Object Functions

In general, any function applicable to Dynamic System Models is
applicable to an `idproc`

model object. These functions are of four general types.

Functions that operate and return

`idproc`

model objects enable you to transform and manipulate`idproc`

models. For instance, use`merge`

to merge estimated`idproc`

models.Functions that perform analytical and simulation functions on

`idproc`

objects, such as`bode`

and`sim`

Functions that retrieve or interpret model information, such as

`advice`

and`getpar`

Functions that convert

`idproc`

objects into a different model type, such as`idpoly`

for time domain or`idfrd`

for frequency domain

The following lists contain a representative subset of the functions that you can use with
`idproc`

models.

## Examples

## Version History

**Introduced before R2006a**