This is machine translation

Translated by Microsoft
Mouseover text to see original. Click the button below to return to the English version of the page.

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.

uss

Uncertain state-space model

Description

Use uss model objects to represent uncertain dynamic systems.

The two dominant forms of model uncertainty are:

  • Uncertainty in parameters of the underlying differential equation models (uncertain state-space matrices)

  • Frequency-domain uncertainty, which often quantifies model uncertainty by describing absolute or relative uncertainty in the frequency response (uncertain or unmodeled linear dynamics)

uss model objects can represent dynamic systems with either or both forms of uncertainty. You can use uss to perform robust stability and performance analysis and to test the robustness of controller designs.

Creation

There are several ways to create a uss model object, including:

  • Use tf with one or more uncertain real parameters (ureal). For example:

    p = ureal('p',1);
    usys = tf(p,[1 p]);

    For another example, see Transfer Function with Uncertain Coefficients.

  • Use ss with uncertain state-space matrices (umat). For example:

    p = ureal('p',1);
    A = [0 3*p; -p p^2];
    B = [0; p];
    C = ones(2);  
    D = zeros(2,1);
    usys = ss(A,B,C,D);

    For another example, see Uncertain State-Space Model.

  • Combine numeric LTI models with uncertain elements using model interconnection commands such as connect, series, or parallel, or model arithmetic operators such as *, +, or -. For example:

     sys = tf(1,[1 1]);
     p = ureal('p',1);
     D = ultidyn('Delta',[1 1]);
     usys = p*sys*(1 + 0.1*D);

    For another example, see System with Uncertain Dynamics.

  • Convert a double array or a numeric LTI model to uss form using usys = uss(sys). In this case, the resulting uss model object has no uncertain elements. For example:

    M = tf(1,[1 1 1]);
    usys = uss(M);
  • Use ucover to create a uss model whose range of possible frequency responses includes all responses in an array of numeric LTI models. The resulting model expresses the range of behaviors as dynamic uncertainty (ultidyn).

Properties

expand all

Nominal value of the uncertain model, specified as a state-space (ss) model object. The state-space model is obtained by setting all the uncertain control design blocks of the uncertain model to their nominal values.

Uncertain elements of the model, specified as a structure whose fields are the names of the uncertain blocks, and whose values are the control design blocks themselves. Thus, the values stored in the structure can be ureal, umat, ultidyn, or other uncertain control design blocks. For instance, the following commands create an uncertain model usys with two uncertain parameters, p1 and p2.

p1 = ureal('p1',1);
p2 = ureal('p2',3);
A = [0 3*p1; -p1 p1^2];
B = [0; p2];
C = ones(2);
D = zeros(2,1);
usys = ss(A,B,C,D);

The Uncertainty property of usys is a structure with two fields, p1 and p2, whose values are the corresponding ureal uncertain parameters.

usys.Uncertainty
ans = 

  struct with fields:

    p1: [1×1 ureal]
    p2: [1×1 ureal]

You can access or examine each uncertain parameter individually. For example:

get(usys.Uncertainty.p1)
    NominalValue: 1
            Mode: 'PlusMinus'
           Range: [0 2]
       PlusMinus: [-1 1]
      Percentage: [-100 100]
    AutoSimplify: 'basic'
            Name: 'p1'

This property is read-only.

State-space matrices, specified as numeric matrices or uncertain matrices (umat). The state-space matrices are evaluated by fixing all dynamic uncertainty blocks (udyn, ultidyn) to their nominal values.

  • A — State matrix A, specified as a square matrix or umat with as many rows and columns as there are system states.

  • B — Input-to-state matrix B, specified as a matrix or umat with as many rows as there are system states and as many columns as there are system inputs.

  • C — State-to-output matrix C, specified as a matrix or umat with as many rows as there are system outputs and as many columns as there are system states.

  • D — Feedthrough matrix D, specified as a matrix or umat with as many rows as there are system outputs and as many columns as there are system inputs.

  • EE matrix for implicit (descriptor) state-space models, specified as a matrix or umat of the same dimensions as A. By default E = [], meaning that the state equation is explicit. To specify an implicit state equation E dx/dt = Ax + Bu, set this property to a square matrix of the same size as A. See dss for more information about descriptor state-space models.

State names, specified as one of these values:

  • Character vector — For first-order models

  • Cell array of character vectors — For models with two or more states

  • '' — For unnamed states

You can specify StateName using a string, such as "velocity", but the state name is stored as a character vector, 'velocity'.

Example: 'velocity'

Example: {'x1','x2'}

State units, specified as one of these values:

  • Character vector — For first-order models

  • Cell array of character vectors — For models with two or more states

  • '' — For states without specified units

Use StateUnit to keep track of the units each state is expressed in. StateUnit has no effect on system behavior.

You can specify StateUnit using a string, such as "mph", but the state units are stored as a character vector, 'mph'.

Example: 'mph'

Example: {'rpm','rad/s'}

Internal delays, specified as a scalar or vector. For continuous-time models, internal delays are expressed in the time unit specified by the TimeUnit property of the model object. For discrete-time models, internal delays are expressed as integer multiples of the sample time Ts. For example, InternalDelay = 3 means a delay of three sampling periods.

You can modify the values of internal delays. However, the number of entries in InternalDelay cannot change, because it is a structural property of the model.

Internal delays arise, for example, when closing feedback loops on systems with delays, or when connecting delayed systems in series or parallel. For more information about internal delays, see Closing Feedback Loops with Time Delays (Control System Toolbox).

Delay at each input, specified as a scalar or a vector. For a system with Nu inputs, set InputDelay to an Nu-by-1 vector. Each entry of this vector is a numerical value that represents the input delay for the corresponding input channel. For continuous-time models, specify input delays in the time unit stored in the TimeUnit property of the model object. For discrete-time models, specify input delays in integer multiples of the sample time Ts. For example, InputDelay = 3 means a delay of three sample times.

Set InputDelay to a scalar value to apply the same delay to all channels.

Delay at each output, specified as a scalar or a vector. For a system with Ny outputs, set OutputDelay to an Ny-by-1 vector. Each entry of this vector is a numerical value that represents the output delay for the corresponding output channel. For continuous-time models, specify output delays in the time unit stored in the TimeUnit property of the model object. For discrete-time models, specify output delays in integer multiples of the sample time Ts. For example, OutputDelay = 3 means a delay of three sample times.

Set OutputDelay to a scalar value to apply the same delay to all channels.

Sample time, specified as:

  • 0 — For continuous-time models.

  • Positive scalar value — For discrete-time models. Specify the sample time in the units given in the TimeUnit property of the model.

  • –1 — For discrete-time models with unspecified sample time.

Changing this property does not discretize or resample the model. Use c2d and d2c to convert between continuous-time and discrete-time representations. Use d2d to change the sample time of a discrete-time system.

Model time units, specified as one of these values:

  • 'nanoseconds'

  • 'microseconds'

  • 'milliseconds'

  • 'seconds'

  • 'minutes'

  • 'hours'

  • 'days'

  • 'weeks'

  • 'months'

  • 'years'

You can specify TimeUnit using a string, such as "hours", but the time units are stored as a character vector, 'hours'.

Model properties such as sample time Ts, InputDelay, OutputDelay, and other time delays are expressed in the units specified by TimeUnit. Changing this property has no effect on other properties, and therefore changes the overall system behavior. Use chgTimeUnit to convert between time units without modifying system behavior.

Names of input channels, specified as one of these values:

  • Character vector — For single-input models

  • Cell array of character vectors — For models with two or more inputs

  • '' — For inputs without specified names

You can use automatic vector expansion to assign input names for multi-input models. For example, if sys is a two-input model, enter:

sys.InputName = 'controls';

The input names automatically expand to {'controls(1)';'controls(2)'}.

You can use the shorthand notation u to refer to the InputName property. For example, sys.u is equivalent to sys.InputName.

Input channel names have several uses, including:

  • Identifying channels on model display and plots

  • Extracting subsystems of MIMO systems

  • Specifying connection points when interconnecting models

You can specify InputName using a string, such as "voltage", but the input name is stored as a character vector, 'voltage'.

Units of input signals, specified as one of these values:

  • Character vector — For single-input models

  • Cell array of character vectors — For models with two or more inputs

  • '' — For inputs without specified units

Use InputUnit to keep track of the units each input signal is expressed in. InputUnit has no effect on system behavior.

You can specify InputUnit using a string, such as "voltage", but the input units are stored as a character vector, 'voltage'.

Example: 'voltage'

Example: {'voltage','rpm'}

Input channel groups, specified as a structure where the fields are the group names and the values are the indices of the input channels belonging to the corresponding group. When you use InputGroup to assign the input channels of MIMO systems to groups, you can refer to each group by name when you need to access it. For example, suppose you have a five-input model sys, where the first three inputs are control inputs and the remaining two inputs represent noise. Assign the control and noise inputs of sys to separate groups.

sys.InputGroup.controls = [1:3];
sys.InputGroup.noise = [4 5];

Use the group name to extract the subsystem from the control inputs to all outputs.

sys(:,'controls')

Example: struct('controls',[1:3],'noise',[4 5])

Names of output channels, specified as one of these values:

  • Character vector — For single-output models

  • Cell array of character vectors — For models with two or more outputs

  • '' — For outputs without specified names

You can use automatic vector expansion to assign output names for multi-output models. For example, if sys is a two-output model, enter:

sys.OutputName = 'measurements';

The output names automatically expand to {'measurements(1)';'measurements(2)'}.

You can use the shorthand notation y to refer to the OutputName property. For example, sys.y is equivalent to sys.OutputName.

Output channel names have several uses, including:

  • Identifying channels on model display and plots

  • Extracting subsystems of MIMO systems

  • Specifying connection points when interconnecting models

You can specify OutputName using a string, such as "rpm", but the output name is stored as a character vector, 'rpm'.

Units of output signals, specified as one of these values:

  • Character vector — For single-output models

  • Cell array of character vectors — For models with two or more outputs

  • '' — For outputs without specified units

Use OutputUnit to keep track of the units each output signal is expressed in. OutputUnit has no effect on system behavior.

You can specify OutputUnit using a string, such as "voltage", but the output units are stored as a character vector, 'voltage'.

Example: 'voltage'

Example: {'voltage','rpm'}

Output channel groups, specified as a structure where the fields are the group names and the values are the indices of the output channels belonging to the corresponding group. When you use OutputGroup to assign the output channels of MIMO systems to groups, you can refer to each group by name when you need to access it. For example, suppose you have a four-output model sys, where the second output is a temperature, and the rest are state measurements. Assign these outputs to separate groups.

sys.OutputGroup.temperature = [2];
sys.InputGroup.measurements = [1 3 4];

Use the group name to extract the subsystem from all inputs to the measurement outputs.

sys('measurements',:)

Example: struct('temperature',[2],'measurement',[1 3 4])

Text notes about the model, stored as a string or a cell array of character vectors. The property stores whichever of these two data types you provide. For instance, suppose that sys1 and sys2 are dynamic system models, and set their Notes properties to a string and a character vector, respectively.

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.'

Data of any kind that you want to associate and store with the model, specified as any MATLAB® data type.

Model name, stored as a character vector. You can specify Name using a string, such as "DCmotor", but the output units are stored as a character vector, 'DCmotor'.

Example: 'system_1'

Sampling grid for model arrays, specified as a structure. For model arrays that are derived by sampling one or more independent variables, this property tracks the variable values associated with each model in the array. 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, suppose you create a 11-by-1 array of linear models, sysarr, by taking snapshots of a linear time-varying system at times t = 0:10. The following code stores the time samples with the linear models.

 sysarr.SamplingGrid = struct('time',0:10)

Similarly, suppose you create a 6-by-9 model array, M, by independently sampling two variables, zeta and w. The following code attaches the (zeta,w) values to M.

[zeta,w] = ndgrid(<6 values of zeta>,<9 values of w>)
M.SamplingGrid = struct('zeta',zeta,'w',w)

When you display M, each entry in the array includes the corresponding zeta and w values.

M
M(:,:,1,1) [zeta=0.3, w=5] =
 
        25
  --------------
  s^2 + 3 s + 25
 

M(:,:,2,1) [zeta=0.35, w=5] =
 
         25
  ----------------
  s^2 + 3.5 s + 25
 
...

For model arrays generated by linearizing a Simulink® model at multiple parameter values or operating points, the software populates SamplingGrid automatically with the variable values that correspond to each entry in the array. For example, the Simulink Control Design™ commands linearize and slLinearizer populate SamplingGrid in this way.

Object Functions

Most functions that work on numeric LTI models also work on uss models. These include model interconnection functions such as connect and feedback, and linear analysis functions such as bode and stepinfo. Some functions that generate plots, such as bode and step, plot random samples of the uncertain model to give you a sense of the distribution of uncertain dynamics. When you use these commands to return data, however, they operate on the nominal value of the system only.

In addition, you can use functions such as robstab and wcgain to perform robustness and worst-case analysis of uncertain systems represented by uss models. You can also use tuning functions such as systune for robust controller tuning.

The following lists contain a representative subset of the functions you can use with uss models.

expand all

feedbackFeedback connection of two models
connectBlock diagram interconnections of dynamic systems
seriesSeries connection of two models
parallelParallel connection of two models
stepStep response plot of dynamic system; step response data
bodeBode plot of frequency response, or magnitude and phase data
sigmaSingular values plot of dynamic system
marginGain margin, phase margin, and crossover frequencies
diskmarginDisk-based stability margins of feedback loops
uss/usampleGenerate random samples of uncertain or generalized model
robstabRobust stability of uncertain system
robgainRobust performance of uncertain system
wcgainWorst-case gain of uncertain system
wcsigmaPlot worst-case gain of uncertain system
dksynRobust controller design using µ-synthesis
systuneTune fixed-structure control systems modeled in MATLAB

Examples

collapse all

Create a second-order transfer function with uncertain natural frequency and damping coefficient.

w0 = ureal('w0',10);
zeta = ureal('zeta',0.7,'Range',[0.6,0.8]);

usys = tf(w0^2,[1 2*zeta*w0 w0^2])
usys =

  Uncertain continuous-time state-space model with 1 outputs, 1 inputs, 2 states.
  The model uncertainty consists of the following blocks:
    w0: Uncertain real, nominal = 10, variability = [-1,1], 5 occurrences
    zeta: Uncertain real, nominal = 0.7, range = [0.6,0.8], 1 occurrences

Type "usys.NominalValue" to see the nominal value, "get(usys)" to see all properties, and "usys.Uncertainty" to interact with the uncertain elements.

usys is an uncertain state-space (uss) model with two Control Design Blocks. The uncertain real parameter w0 occurs five times in the transfer function, twice in the numerator and three times in the denominator. To reduce the number of occurrences, you can rewrite the transfer function by dividing numerator and denominator by w0^2.

usys = tf(1,[1/w0^2 2*zeta/w0 1])
usys =

  Uncertain continuous-time state-space model with 1 outputs, 1 inputs, 2 states.
  The model uncertainty consists of the following blocks:
    w0: Uncertain real, nominal = 10, variability = [-1,1], 3 occurrences
    zeta: Uncertain real, nominal = 0.7, range = [0.6,0.8], 1 occurrences

Type "usys.NominalValue" to see the nominal value, "get(usys)" to see all properties, and "usys.Uncertainty" to interact with the uncertain elements.

In the new formulation, there are only three occurrences of the uncertain parameter w0. Reducing the number of occurrences of a Control Design Block in a model can improve the performance of calculations involving the model.

Examine the step response of the system to get a sense of the range of responses that the uncertainty represents.

step(usys)

When you use linear analysis commands like step and bode to create response plots of uncertain systems, they automatically plot random samples of the system. While these samples give you a sense of the range of responses that fall within the uncertainty, they do not necessarily include the worst-case response. To analyze worst-case responses of uncertain systems, use wcgain or wcsigma.

To create an uncertain state-space model, you first use Control Design Blocks to create uncertain elements. Then, use the elements to specify the state-space matrices of the system.

For instance, create three uncertain real parameters and build state-spaces matrices from them.

p1 = ureal('p1',10,'Percentage',50); 
p2 = ureal('p2',3,'PlusMinus',[-.5 1.2]); 
p3 = ureal('p3',0); 

A = [-p1 p2; 0 -p1]; 
B = [-p2; p2+p3]; 
C = [1 0; 1 1-p3]; 
D = [0; 0];

The matrices constructed with uncertain parameters, A, B, and C, are uncertain matrix (umat) objects. Using them as inputs to ss results in a 2-output, 1-input, 2-state uncertain system.

sys = ss(A,B,C,D)
sys =

  Uncertain continuous-time state-space model with 2 outputs, 1 inputs, 2 states.
  The model uncertainty consists of the following blocks:
    p1: Uncertain real, nominal = 10, variability = [-50,50]%, 2 occurrences
    p2: Uncertain real, nominal = 3, variability = [-0.5,1.2], 2 occurrences
    p3: Uncertain real, nominal = 0, variability = [-1,1], 2 occurrences

Type "sys.NominalValue" to see the nominal value, "get(sys)" to see all properties, and "sys.Uncertainty" to interact with the uncertain elements.

The display shows that the system includes the three uncertain parameters.

Create an uncertain system comprising a nominal model with a frequency-dependent amount of uncertainty. You can model such uncertainty using ultidyn and a weighting function that represents the frequency profile of the uncertainty. Suppose that at low frequency, below 3 rad/s, the model can vary up to 40% from its nominal value. Around 3 rad/s, the percentage variation starts to increase. The uncertainty crosses 100% at 15 rad/s and reaches 2000% at approximately 1000 rad/s. Create a transfer function with an appropriate frequency profile, Wunc, to use as a weighting function that modulates the amount of uncertainty with frequency.

Wunc = makeweight(0.40,15,3);
bodemag(Wunc)

Next, create a transfer function representing the nominal value of the system. For this example, use a transfer function with a single pole at s = –60 rad/s. Then, create a ultidyn model to represent 1-input, 1-output uncertain dynamics, and add the weighted uncertainty to the nominal transfer function.

sysNom = tf(1,[1/60 1]);
unc = ultidyn('unc',[1 1],'SampleStateDim',3); % samples of uncertain dynamics have three states

usys = sysNom*(1 + Wunc*unc);

% Set properties of usys
usys.InputName = 'u';
usys.OutputName = 'fs';

Examine random samples of usys to see the effect of the uncertain dynamics.

bode(usys,usys.Nominal)

uss models, like all model objects, include properties that store dynamics and model metadata. View the properties of an uncertain state-space model.

p1 = ureal('p1',10,'Percentage',50);
p2 = ureal('p2',3,'PlusMinus',[-.5 1.2]);
p3 = ureal('p3',0);
A = [-p1 p2; 0 -p1];
B = [-p2; p2+p3];
C = [1 0; 1 1-p3];
D = [0; 0];
sys = ss(A,B,C,D);     % create uss model

get(sys)
     NominalValue: [2x1 ss]
      Uncertainty: [1x1 struct]
                A: [2x2 umat]
                B: [2x1 umat]
                C: [2x2 umat]
                D: [2x1 double]
                E: []
        StateName: {2x1 cell}
        StateUnit: {2x1 cell}
    InternalDelay: [0x1 double]
       InputDelay: 0
      OutputDelay: [2x1 double]
               Ts: 0
         TimeUnit: 'seconds'
        InputName: {''}
        InputUnit: {''}
       InputGroup: [1x1 struct]
       OutputName: {2x1 cell}
       OutputUnit: {2x1 cell}
      OutputGroup: [1x1 struct]
            Notes: [0x1 string]
         UserData: []
             Name: ''
     SamplingGrid: [1x1 struct]

Most of the properties behave similarly to how they behave for ss model objects. The NominalValue property is itself an ss model object. You can therefore analyze the nominal value as you would any state-space model. For instance, compute the poles and step response of the nominal system.

pole(sys.NominalValue)
ans = 2×1

   -10
   -10

step(sys.NominalValue)

As with the uncertain matrices (umat), the Uncertainty property is a structure containing the uncertain elements. You can use this property for direct access to the uncertain elements. For instance, check the Range of the uncertain element named p2 within sys.

sys.Uncertainty.p2.Range
ans = 1×2

    2.5000    4.2000

Change the uncertainty range of p2 within sys.

sys.Uncertainty.p2.Range = [2 4];

This command changes only the range of the parameter called p2 in sys. It does not change the variable p2 in the MATLAB workspace.

p2.Range
ans = 1×2

    2.5000    4.2000

Introduced before R2006a