StateSpaceModel
StateSpaceModel[{a,b,c,d}]
represents the standard state-space model with state matrix a, input matrix b, output matrix c, and transmission matrix d.
StateSpaceModel[{a,b,c,d,e}]
represents a descriptor state-space model with descriptor matrix e.
StateSpaceModel[sys]
gives a state-space model corresponding to the systems model sys.
StateSpaceModel[eqns,{{x1,x10},…},{{u1,u10},…},{g1,…},τ]
gives the state-space model obtained by Taylor linearization about the point (xi0,ui0) of the differential or difference equations eqns with outputs gi and independent variable τ.
Details and Options
- StateSpaceModel is also known as an LTI system (linear time-invariant).
- StateSpaceModel is typically used as a linearized model of a system for controller design.
- A continuous-time system modeled by the equations
with states 
, control inputs 
, and outputs 
can be specified as StateSpaceModel[{a,b,c,d}]. - A discrete-time system modeled by the equations
with states 
, control inputs 
, outputs 
, and sampling period τ can be specified as StateSpaceModel[{a,b,c,d},SamplingPeriod->τ]. - Descriptor systems can be specified as follows:
-
StateSpaceModel[{a,b,c,d,e}] 
StateSpaceModel[{a,b,c,d,e},SamplingPeriod->τ] 
- Time delay systems can be represented by using SystemsModelDelay in any of the matrices.
- For a system with n states, p inputs and q outputs, the matrices a, b, c, d and e should have dimensions {n,n}, {n,p}, {q,n}, {q,p} and {n,n}.
- The following short inputs can be used:
-
StateSpaceModel[{a,b,c}] 
StateSpaceModel[{a,b}] 
StateSpaceModel[{a,b,c,Automatic,e}] 
StateSpaceModel[{a,b,Automatic,Automatic,e}] 
- In StateSpaceModel[sys] the following systems can be converted:
-
AffineStateSpaceModel approximate Taylor conversion NonlinearStateSpaceModel approximate Taylor conversion TransferFunctionModel exact conversion - When converting from transfer-function model sys, the controllable realization is used.
- For equational input, default linearization points xi0 and uj0 are taken to be zero.
- StateSpaceModel[…]["prop"] gives the value of the property "prop".
- StateSpaceModel[…]["Properties"] gives the list of available properties.
- The following options can be given:
-
Appearance Automatic model appearance DescriptorStateSpace Automatic standard or descriptor realization ExternalTypeSignature Automatic variable types for embedded code SamplingPeriod Automatic the sampling period StateSpaceRealization Automatic the canonical realization SystemsModelLabels Automatic the labels for the input, output, and state variables - The option Appearance can take values Automatic, "Detailed", "Structured", "Elided", and "Iconized".
[image][image]Examples
open all close allBasic Examples (5)
Construct a state-space model from state, input, output and transmission matrices:
{a, b, c, d} = {(| | |
| --- | --- |
| 𝒶11 | 𝒶12 |
| 𝒶21 | 𝒶22 |), (| |
| --- |
| 𝒷11 |
| 𝒷21 |), (Subscript[𝒸, 11] Subscript[𝒸, 12]), {{Subscript[𝒹, 11]}}};ssm = StateSpaceModel[{a, b, c, d}]SystemsModelOrder[ssm]Construct a state-space model from a transfer function model:
ssm = StateSpaceModel[TransferFunctionModel[{{{1}, {1 - s}}, {{5 + s},
{-4 + s^2}}}, s]]Test its controllability and observability:
Through[{ControllableModelQ, ObservableModelQ}[ssm]]Construct a state-space model from a set of ordinary differential equations (ODEs):
eqns = {Subscript[x, 1]'[t] == 3 Subscript[u, 1][t] - Subscript[x, 1][t] - 5 Subscript[x, 2][t], Subscript[x, 2]'[t] == -3 Subscript[u, 2][t] - Subscript[x, 2][t] + Subscript[x, 3][t], Subscript[x, 3]'[t] == -5 Subscript[u, 1][t] + 2 Subscript[x, 1][t] - 2 Subscript[x, 3][t]};ssm = StateSpaceModel[eqns, {Subscript[x, 1][t], Subscript[x, 2][t], Subscript[x, 3][t]}, {Subscript[u, 1][t], Subscript[u, 2][t]}, {Subscript[x, 1][t], Subscript[x, 2][t]}, t, SystemsModelLabels -> {{Subscript[u, 1], Subscript[u, 2]}, {Subscript[x, 1], Subscript[x, 2]}, {Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]}}]Its response to nonzero initial conditions:
InputOutputResponse[{ssm, {0.1, 0.2, 0.05}}, {0, 0}, {t, 0, 10}];
Plot[%, {t, 0, 10}, PlotRange -> All, PlotLegends -> {Subscript[x, 1], Subscript[x, 2]}]Construct a discrete-time state-space model by specifying its sampling period:
{a, b, c, d} = {{{-0.3, 0}, {0, 0.5}}, {{1}, {-1}}, {{1, 0}}, {{0}}};
dssm = StateSpaceModel[{a, b, c, d}, SamplingPeriod -> 1]InputOutputResponse[dssm, Table[1, 10]];
ListStepPlot[%, DataRange -> {0, 10}, PlotRange -> All]Obtain a state space model's equations as a property:
StateSpaceModel[{{{0, 1, 0}, {0, 0, 1}, {-80, -66, -15}}, {{0}, {0}, {1}}, {{3, 1, 0}}, {{0}}}]["Equations"]Scope (39)
Basic Uses (12)
A state-space model with a state, input, output and transmission matrices:
{a, b, c, d} = {(| | |
| -- | -- |
| -1 | 0 |
| 0 | -2 |), (| |
| - |
| 1 |
| 2 |), (1 1), (1)};ssm = StateSpaceModel[{a, b, c, d}]Its response to a unit-step input:
OutputResponse[ssm, UnitStep[t], {t, 0, 10}];
Plot[%, {t, 0, 10}, PlotRange -> All]A state-space model specified using only state, input and output matrices:
{a, b, c} = {(| | |
| -- | -- |
| -1 | 0 |
| 0 | -2 |), (| |
| -- |
| 1 |
| -1 |), (1 0)};StateSpaceModel[{a, b, c}]The transmission matrix is assumed to be a zero matrix:
StateSpaceModel[{a, b, c, {{0}}}]A state-space model specified using only state and input matrices:
{a, b, c, d} = {(| | |
| -- | -- |
| -1 | 0 |
| 0 | -2 |), (| |
| -- |
| 1 |
| -1 |), (| | |
| - | - |
| 1 | 0 |
| 0 | 1 |), (| |
| - |
| 0 |
| 0 |)};ssm = StateSpaceModel[{a, b}]The states are assumed to be the outputs:
ssm1 = StateSpaceModel[{a, b, c, d}]Both models have the same output response:
Equal@@Table[OutputResponse[sys, UnitStep[t], t], {sys, {ssm, ssm1}}]A discrete-time model with a sampling period of 0.1:
ssm = StateSpaceModel[{(| | |
| - | -- |
| 0 | 1 |
| 0 | -1 |), (| |
| - |
| 0 |
| 1 |), (1 0)}, SamplingPeriod -> 0.1]Test its controllability and observability:
Through[{ControllableModelQ, ObservableModelQ}[ssm]]A model with 3 states, 2 inputs and 1 output:
ssm = StateSpaceModel[{(| | | |
| -- | -- | -- |
| -1 | 2 | 1 |
| -1 | -2 | -1 |
| -2 | 0 | -2 |), (| | |
| -- | - |
| -1 | 0 |
| -1 | 1 |
| 0 | 2 |), (1 -1 0)}]Count the number of inputs and outputs:
SystemsModelDimensions[ssm]A model with 3 states, 1 input and 2 outputs:
ssm = StateSpaceModel[{(| | | |
| -- | -- | -- |
| -1 | 2 | 1 |
| -1 | -2 | -1 |
| -2 | 0 | -2 |), (| |
| -- |
| -1 |
| -1 |
| 0 |), (| | | |
| - | -- | - |
| 1 | -1 | 0 |
| 1 | 0 | 1 |)}]SystemsModelDimensions[ssm]A multiple-input multiple-output (MIMO) model:
ssm = StateSpaceModel[{(| | | |
| -- | -- | -- |
| -1 | 2 | 1 |
| -1 | -2 | -1 |
| -2 | 0 | -2 |), (| | |
| -- | --- |
| -1 | 0.2 |
| -1 | 1 |
| 0 | 2 |), (| | | |
| - | -- | - |
| 1 | -1 | 0 |
| 1 | 0 | 1 |)}]SystemsModelDimensions[ssm]ssm = StateSpaceModel[{(| | |
| ------ | ------ |
| 0 | 1 |
| -(k/m) | -(c/m) |), (| |
| ------------------ |
| (c/m) |
| -(c^2/m^2) + (k/m) |), (1 0)}]Compute the analytical unit-step response:
OutputResponse[ssm, UnitStep[t], t]//FullSimplifyStateSpaceModel[{(| | |
| -- | - |
| -3 | 0 |
| 2 | 1 |), {{0}, {1}}, {{1, 0}}}, {Subscript[x, 1], Subscript[x, 2]}]They are visible in the AffineStateSpaceModel representation:
AffineStateSpaceModel[%]If no state variables are specified, they are chosen automatically:
StateSpaceModel[{(| | |
| -- | - |
| -3 | 0 |
| 2 | 1 |), {{0}, {1}}, {{1, 0}}}];AffineStateSpaceModel[%]Specify the state, input and output variables:
StateSpaceModel[{(| | |
| -- | - |
| -3 | 0 |
| 2 | 1 |), {{0}, {1}}, {{1, 0}}}, {Subscript[x, 1], Subscript[x, 2]}, u, Subscript[y, 1]]The NonlinearStateSpaceModel representation:
NonlinearStateSpaceModel[%]Use a state-space model to design a pole-placement controller:
ssm = StateSpaceModel[{{{-1, 2, 1}, {-1, -2, -1}, {-2, 0, -2}}, {{-1}, {-1}, {0}}},
SamplingPeriod -> None, SystemsModelLabels -> None];The controller design that places the poles at 
:
𝒸𝒹 = StateFeedbackGains[ssm, {-1, -2, -3}, "Data"]The open- and closed-loop poles:
Map[𝒸𝒹, {"OpenLoopPoles", "ClosedLoopPoles"}]Plot the response of the closed-loop system to a set of initial conditions:
StateResponse[{𝒸𝒹["ClosedLoopSystem"], {0.1, 0.2, 0.3}}, 0, {t, 0, 5}];
Plot[%, {t, 0, 5}, PlotRange -> All]Descriptor Models (6)
Descriptor models are used to model algebraic equations:
ssm = StateSpaceModel[{(-1), (2), (1), (0), (0)}]It modeled the equation 
, where 
is the input signal and 
is the output:
TransferFunctionModel[ssm]By default, the descriptor matrix e is assumed to be the identity matrix:
{a, b, c, d, e} = {(| | |
| -- | -- |
| 0 | 1 |
| -2 | -3 |), (| |
| - |
| 0 |
| 1 |), (1 0), (0), (| | |
| - | - |
| 1 | 0 |
| 0 | 1 |)};ssm = StateSpaceModel[{a, b, c, d}]It is equivalent to the following model with an identity descriptor matrix:
ssm1 = StateSpaceModel[{a, b, c, d, e}]Both models have the same state response:
Equal@@Table[StateResponse[sys, UnitStep[t], t], {sys, {ssm, ssm1}}]Use Automatic to create a descriptor system with all the states as outputs:
ssm = StateSpaceModel[{(| | |
| -- | -- |
| 1 | 0 |
| -2 | -1 |), (| |
| - |
| 1 |
| 0 |), Automatic, Automatic, (| | |
| - | ---- |
| 1 | -0.5 |
| 0 | 1 |)}]Its state and output responses are the same:
StateResponse[ssm, UnitStep[t], t] - OutputResponse[ssm, UnitStep[t], t]It may be possible to convert a descriptor model to a standard model:
StateSpaceModel[StateSpaceModel[{{{Subscript[a, 1], 0}, {0, Subscript[a, 2]}},
{{Subscript[b, 1]}, {Subscript[b, 2]}},
{{Subscript[c, 1], Subscript[c, 2]}}, {{d}},
{{Subscript[e, 1], 0}, {0, Subscript[e, 2]}}}, SamplingPeriod -> None,
SystemsModelLabels -> None], DescriptorStateSpace -> False]A model with a singular descriptor matrix:
ssm = StateSpaceModel[{(| | |
| -- | - |
| -3 | 1 |
| 0 | 1 |), (| |
| - |
| 0 |
| 1 |), (1 0), (0), (| | |
| - | - |
| 1 | 1 |
| 0 | 0 |)}]It is still possible to convert it to a standard system:
StateSpaceModel[ssm, DescriptorStateSpace -> False]It may not be possible to convert a descriptor model to a standard one in all cases:
ssm = StateSpaceModel[{(| | | |
| -- | - | - |
| -4 | 0 | 0 |
| 0 | 1 | 0 |
| 0 | 0 | 1 |), (| |
| -- |
| 16 |
| 1 |
| -4 |), (1 0 -1), (0), (| | | |
| - | - | - |
| 1 | 0 | 0 |
| 0 | 0 | 0 |
| 0 | 1 | 0 |)}]StateSpaceModel[ssm, DescriptorStateSpace -> False]
Time-Delay Models (3)
Use SystemsModelDelay to model a system with delays:
ssm = StateSpaceModel[{(-2), (1), ( Subscript[, 3])}]It has a delayed output response:
OutputResponse[ssm, UnitStep[t], {t, 0, 8}];
Plot[%, {t, 0, 8}, PlotRange -> All]A system with two input delays:
ssm = StateSpaceModel[{(| | |
| -- | ---- |
| 0 | 1 |
| -1 | -0.1 |), (| |
| -- |
| 2 |
| 4 |), (1 1)}]OutputResponse[ssm, UnitStep[t], {t, 0, 5}];
Plot[%, {t, 0, 5}, PlotRange -> All]A discrete-time system with a delay in the state matrix:
StateSpaceModel[{(a Subscript[, δ]), (b), (c)}, SamplingPeriod -> τ]TransferFunctionModel[%]Model Conversions (13)
A state-space model of a transfer-function model:
tfm = TransferFunctionModel[{{{1}}, -3 + 2*s + s^2}, s];ssm1 = StateSpaceModel[tfm]The state-space representation is not unique:
ssm2 = StateSpaceModel[tfm, StateSpaceRealization -> "Observable"]Both yield same original transfer-function model:
TransferFunctionModel /@ {ssm1, ssm2}A state-space model of a discrete-time transfer-function model:
StateSpaceModel[TransferFunctionModel[{{{2 + z}}, -1 + 5*z + z^2},
z, SamplingPeriod -> 0.1]]A state-space model of an improper transfer-function model yields a descriptor system:
StateSpaceModel[TransferFunctionModel[{{{1 + s^2}}, 2 + s}, s]]A state-space model of an affine state-space model discards all nonlinearities:
StateSpaceModel[AffineStateSpaceModel[{{Subscript[x, 1] + Subscript[x, 2]^2,
(-Subscript[x, 1])*Subscript[x, 2]},
{{1}, {Subscript[x, 1]}}, {Subscript[x, 1]}, {{0}}},
{Subscript[x, 1], Subscript[x, 2]}, {u}, {Automatic},
Automatic, SamplingPeriod -> None]]The original model cannot be fully recovered from the linearized model:
AffineStateSpaceModel[%]If the affine state-space model is linear, no information is lost:
StateSpaceModel[AffineStateSpaceModel[{{2*Subscript[x, 1], 3*Subscript[x, 1] -
4*Subscript[x, 2]}, {{0}, {1}}, {Subscript[x, 1]}, {{0}}},
{Subscript[x, 1], Subscript[x, 2]}, Automatic, {Automatic}, Automatic,
SamplingPeriod -> None]]And the original model can be fully recovered:
AffineStateSpaceModel[%]A state-space model of a nonlinear state-space model discards all nonlinearities:
nssm = NonlinearStateSpaceModel[{{-Subscript[x, 2], u + u^2 +
u*Subscript[x, 1] - Subscript[x, 2] +
u*Subscript[x, 2] + Subscript[x, 1]*
Subscript[x, 2]}, {-Subscript[x, 1]}},
{Subscript[x, 1], Subscript[x, 2]}, {u}, {Automatic},
Automatic, SamplingPeriod -> None];ssm = StateSpaceModel[nssm]The original model cannot be fully recovered from the linearized model:
NonlinearStateSpaceModel[ssm]Their output responses are not the same:
Table[OutputResponse[sys, Sin[t], {t, 0, 30}], {sys, {nssm, ssm}}];
Plot[%, {t, 0, 30}, IconizedObject[«plotOpts»]]If the nonlinear state-space model is linear, no information is lost:
StateSpaceModel[NonlinearStateSpaceModel[{{-2 + Subscript[x, 1] + Subscript[x, 2],
-u + 3*Subscript[x, 2]}, {Subscript[x, 1],
Subscript[x, 2]}}, {Subscript[x, 1], Subscript[x, 2]},
{u}, {Automatic, Automatic}, Automatic, SamplingPeriod -> None]]And the original model can be fully recovered:
NonlinearStateSpaceModel[%]A state-space model of a system of ODEs:
eqns = {Subscript[x, 1]'[t] == -2Subscript[x, 1][t] + 3Subscript[x, 2][t] - u[t], Subscript[x, 2]'[t] == 3Subscript[x, 1][t] - Subscript[x, 2][t]};StateSpaceModel[eqns, {Subscript[x, 1][t], Subscript[x, 2][t]}, u[t], Subscript[x, 1][t], t]If the ODEs have nonlinear terms they are approximated:
eqns = {Subscript[x, 1]'[t] == 3 Sin[Subscript[x, 2][t]] + Subscript[x, 1][t] - u[t], Subscript[x, 2]'[t] == Subscript[x, 1][t] + Subscript[x, 1][t]Subscript[x, 2][t]};StateSpaceModel[eqns, {Subscript[x, 1][t], Subscript[x, 2][t]}, u[t], Subscript[x, 1][t], t]The nonlinear representation does not approximate the nonlinear terms:
NonlinearStateSpaceModel[eqns, {Subscript[x, 1][t], Subscript[x, 2][t]}, u[t], Subscript[x, 1][t], t]A state-space model of a set of difference equations:
dEqns = {Subscript[x, 1][k + 1] == Subscript[x, 1][k] - 3Subscript[x, 2][k], Subscript[x, 2][k + 1] == 4Subscript[x, 1][k] + Subscript[x, 2][k] - u[k]};StateSpaceModel[dEqns, {Subscript[x, 1][k], Subscript[x, 2][k]}, u[k], Subscript[x, 1][k], k]A state-space model of a set of differential-algebraic equations:
eqns = {Subscript[x, 1]'[t] == -1.0Subscript[x, 1][t] + Subscript[x, 2][t] + u[t], Subscript[x, 2][t] + Subscript[x, 1][t] == 0};StateSpaceModel[eqns, {Subscript[x, 1][t], Subscript[x, 2][t]}, {u[t]}, Subscript[x, 1][t], t]//ChopPrevent elimination of the algebraic equation:
StateSpaceModel[eqns, {Subscript[x, 1][t], Subscript[x, 2][t]}, {u[t]}, Subscript[x, 1][t], t, DescriptorStateSpace -> True]A state-space model of a set of difference-algebraic equations:
eqns = {x[k + 1] == 0.5x[k], y[k] == -x[k] + u[k]};StateSpaceModel[eqns, {x[k], y[k]}, {u[k]}, {x[k]}, k]Prevent elimination of the algebraic equation:
StateSpaceModel[eqns, {x[k], y[k]}, {u[k]}, {x[k]}, k, DescriptorStateSpace -> True]A state-space model of a delay-differential equation:
eqn = {x'[t] == -x[t - 3] + u[t]};StateSpaceModel[eqn, {x[t]}, {u[t]}, {x[t]}, t]Properties (5)
StateSpaceModel[{{{0, 1}, {-10, -7}}, {{0}, {1}}, {{1, 1}}, {{0}}}, SamplingPeriod -> None,
SystemsModelLabels -> None]["StateEquations"]StateSpaceModel[{{{0, 1}, {-10, -7}}, {{0}, {1}}, {{1, 1}}, {{0}}}, SamplingPeriod -> None,
SystemsModelLabels -> None][{"StateMatrix", "OutputExpressions"}]The list of available properties:
StateSpaceModel[{{{0, 1}, {-10, -7}}, {{0}, {1}}, {{1, 1}}, {{0}}}, SamplingPeriod -> None,
SystemsModelLabels -> None]["Properties"]All available properties as an Association:
StateSpaceModel[{{{0, 1}, {-10, -7}}, {{0}, {1}}, {{1, 1}}, {{0}}}, SamplingPeriod -> None,
SystemsModelLabels -> None]["PropertyAssociation"]As a Dataset:
StateSpaceModel[{{{0, 1}, {-10, -7}}, {{0}, {1}}, {{1, 1}}, {{0}}}, SamplingPeriod -> None,
SystemsModelLabels -> None]["PropertyDataset"]Options (17)
Appearance (3)
By default, the appearance is selected to fit the display in the notebook:
StateSpaceModel[{RandomReal[{-1, 1}, {10, 10}], RandomReal[{-1, 1}, {10, 6}]}]StateSpaceModel[{RandomReal[{-1, 1}, {2, 2}], RandomReal[{-1, 1}, {2, 2}]}]StateSpaceModel[{RandomReal[{-1, 1}, {10, 10}], RandomReal[{-1, 1}, {10, 6}]}, Appearance -> "Elided"]StateSpaceModel[{RandomReal[{-1, 1}, {10, 10}], RandomReal[{-1, 1}, {10, 6}]}, Appearance -> "Iconized"]Specify a custom icon for the iconized appearance:
StateSpaceModel[m x''[t] == -k x[t] - c x'[t] + f[t], {x[t], x'[t]}, f[t], x[t], t, Appearance -> "Iconized", InputOutputModelIcon -> IconizedObject[«icon»]]DescriptorStateSpace (3)
Convert a standard state-space model to a descriptor model:
StateSpaceModel[StateSpaceModel[{{{0, 1}, {-1, -2}}, {{0}, {1}}, {{1, 0}}, {{0}}}, SamplingPeriod -> None,
SystemsModelLabels -> None], DescriptorStateSpace -> True]It may sometimes be possible to convert a descriptor state-space model to a standard one:
StateSpaceModel[StateSpaceModel[{{{0, 1}, {-1, -2}}, {{0}, {1}}, {{1, 0}}, {{0}}, {{1, 0.6}, {0.9, 1}}},
SamplingPeriod -> None, SystemsModelLabels -> None], DescriptorStateSpace -> False]Obtain the state-space representation of a difference equation as a descriptor model:
StateSpaceModel[4 x[k + 1] == 0.9x[k] + u[k], x[k], u[k], x[k], k, DescriptorStateSpace -> True]SamplingPeriod (3)
By default, a continuous-time model is constructed:
ssm = StateSpaceModel[IconizedObject[«abcd»]]ContinuousTimeModelQ[ssm]Explicitly construct a continuous-time model:
ssm = StateSpaceModel[IconizedObject[«abcd»], SamplingPeriod -> None]ContinuousTimeModelQ[ssm]A discrete-time model with sampling period τ:
ssm = StateSpaceModel[{(| | |
| ---- | --- |
| 1 | 0.5 |
| -0.5 | 0.5 |), (| |
| - |
| 1 |
| 0 |), (1 0)}, SamplingPeriod -> τ]Assign a numerical value to τ:
ssm = ssm /. τ -> 0.2OutputResponse[ssm, PadRight[{1}, 10]];
ListStepPlot[%, DataRange -> {0, (10 - 1) 0.2}, PlotRange -> All]StateSpaceRealization (4)
By default, the controllable companion realization is computed:
StateSpaceModel[TransferFunctionModel[
{{{b3 + b2*z + b1*z^2 +
b0*z^3}}, a3 + a2*z +
a1*z^2 + z^3}, z]]Explicitly compute the controllable companion realization:
StateSpaceModel[TransferFunctionModel[
{{{b3 + b2*z + b1*z^2 +
b0*z^3}}, a3 + a2*z +
a1*z^2 + z^3}, z], StateSpaceRealization -> "ControllableCompanion"]The observable companion realization:
StateSpaceModel[TransferFunctionModel[
{{{b3 + b2*z + b1*z^2 +
b0*z^3}}, a3 + a2*z +
a1*z^2 + z^3}, z], StateSpaceRealization -> "ObservableCompanion"]It is the dual of the controllable companion realization:
Simplify[DualSystemsModel[%], Element[_, Reals]]The controllable and controllable companion realizations for a MIMO transfer-function model:
Table[StateSpaceModel[TransferFunctionModel[{{{5 - 6* + ^2, -7 + }, {-4, -1 - }},
33 - 5* - 5*^2 + ^3}, , Appearance -> "Detailed"], StateSpaceRealization -> i], {i, {"Controllable", "ControllableCompanion"}}]The observable and observable companion realizations for a MIMO transfer-function model:
tfm = TransferFunctionModel[{{{5 - 6* + ^2, -7 + }, {-4, -1 - }},
33 - 5* - 5*^2 + ^3}, ];Table[StateSpaceModel[tfm, StateSpaceRealization -> i], {i, {"Observable", "ObservableCompanion"}}]They have a dual relationship with the controllable and controllable companion realizations:
DualSystemsModel /@ %Table[StateSpaceModel[TransferFunctionModel[tfm[s], s], StateSpaceRealization -> i], {i, {"Controllable", "ControllableCompanion"}}]SystemsModelLabels (4)
Label the inputs, outputs and states:
lbls = {{"SubscriptBox[δ, c]", "SubscriptBox[δ, f]"}, {"θ", "OverscriptBox[θ, ]", "γ"}, {"θ", "α", "OverscriptBox[θ, ]"}};StateSpaceModel[IconizedObject[«abc»], SystemsModelLabels -> lbls]Label only the inputs and outputs:
{inLbls, outLbls} = {{"SubscriptBox[δ, c]", "SubscriptBox[δ, f]"}, {"θ", "OverscriptBox[θ, ]", "γ"}};StateSpaceModel[IconizedObject[«abc»], SystemsModelLabels -> {inLbls, outLbls}]StateSpaceModel[IconizedObject[«abc»], SystemsModelLabels -> {{"SubscriptBox[δ, c]", "SubscriptBox[δ, f]"}}]StateSpaceModel[IconizedObject[«abc»], SystemsModelLabels -> {None, {"θ", "OverscriptBox[θ, ]", "γ"}}]Applications (33)
Mechanical Systems (11)
Compute a state-space model of a mass-spring damper system using Newton's second law:
Assemble the equation of the system using 
:
eqn = m x''[t] == -k x[t] - c x'[t] + f[t];It is linear and can be put into a linear state-space form without any approximations:
ssm = StateSpaceModel[eqn, {x[t], x'[t]}, f[t], x[t], t]TransferFunctionModel[ssm]//SimplifyThe response of the model to a unit-step input:
InputOutputResponse[ssm, 1, t]//FullSimplifyCompute a state-space model of an inverted pendulum using the Lagrangian:
Subscript[r, p] = Composition[TranslationTransform[{x[t], 0, 0}], RotationTransform[θ[t], {0, 0, 1}]][{0, 1, 0}]Subscript[v, p] = D[Subscript[r, p], t]The kinetic energy of the cart and pendulum:
𝒦 = (1/2)Subscript[m, 1] x'[t]^2 + (1/2)Subscript[m, 2]Subscript[v, p].Subscript[v, p]The potential energy of the pendulum:
𝒰 = Subscript[m, 1]g Subscript[r, p][[2]]ℒ = 𝒦 - 𝒰{Subscript[f, x], Subscript[f, θ]} = D[f[t] δx - Subscript[b, x]x'[t]δx - Subscript[b, θ]θ'[t]δθ, {{δx, δθ}}]eqns = Table[Subscript[∂, t]D[ℒ, q'[t]] - D[ℒ, q[t]] == Subscript[f, q], {q, {x, θ}}]//Simplifyssm = StateSpaceModel[eqns, {x[t], x'[t], θ[t], θ'[t]}, f[t], {x[t], θ[t]}, t, IconizedObject[«labels»]]The nonpositive eigenvalues make it an unstable system:
Eigenvalues[First[Normal[ssm /. {Subscript[m, 1] -> 0.5, Subscript[m, 2] -> 0.1, l -> 0.3, g -> 9.81, Subscript[b, x] -> 0.15, Subscript[b, θ] -> 0.01}]]]Compute the state-space model of a vibration absorber using the Lagrangian and the Rayleigh dissipation function:
The kinetic energy of the system:
𝒦 = (1/2)m x'[t]^2 + (1/2)ma xa'[t]^2𝒰 = (1/2)ka(xa[t] - x[t])^2 + (1/2)k x[t]^2 + m g(l + x[t]) + ma g(la + xa[t])ℒ = 𝒦 - 𝒰The Rayleigh dissipation function:
ℛ = (1/2)ca(xa'[t] - x'[t])^2 + (1/2)c x'[t]^2The system's equations of motion:
eqns = Thread[Table[Subscript[∂, t]D[ℒ, q'[t]] - D[ℒ, q[t]] + D[ℛ, q'[t]], {q, {x, xa}}] == {f[t] - u[t], u[t]}]eqns /. Derivative[_][_][_] :> 0 /. (f | u)[t] -> 0;
eqlPos = Solve[%, {x[t], xa[t]}][[1]]A state-space model of the system:
ssm = StateSpaceModel[eqns, eqlPos, {f[t], u[t]}, {x[t], xa[t]}, t, IconizedObject[«labels»]]ssmN = ssm /. {m -> 1.2, ma -> 0.25, k -> 0.5, ka -> 0.3, c -> 0.7, ca -> 0.85}Its response to an oscillatory disturbance:
OutputResponse[ssmN, {Sin[3t], 0}, {t, 0, 30}];
Plot[%, {t, 0, 30}, PlotRange -> All, PlotLegends -> {x, xa}]Compute the state-space model of a multidomain system consisting of a motor with a load on a flexible shaft:
𝒦 = (1/2)Subscript[j, 1] Subscript[ϕ, 1]'[t]^2 + (1/2)Subscript[j, 2] Subscript[ϕ, 2]'[t]^2;𝒰 = (1/2) k(Subscript[ϕ, 2][t] - Subscript[ϕ, 1][t])^2;ℒ = 𝒦 - 𝒰//FullSimplify
{Subscript[τ, Subscript[ϕ, 1]], Subscript[τ, Subscript[ϕ, 2]]} = D[Subscript[τ, d][t] Subscript[δϕ, 2] - c( Subscript[ϕ, 2]'[t] - Subscript[ϕ, 1]'[t])Subscript[δϕ, 2] - c (Subscript[ϕ, 1]'[t] - Subscript[ϕ, 2]'[t])Subscript[δϕ, 1] - Subscript[c, 1]Subscript[ϕ, 1]'[t]Subscript[δϕ, 1] - Subscript[c, 2]Subscript[ϕ, 2]'[t]Subscript[δϕ, 2] + Subscript[k, i] i[t]Subscript[δϕ, 1], {{Subscript[δϕ, 1], Subscript[δϕ, 2]}}]eqns = Table[Subscript[∂, t]D[ℒ, q'[t]] - D[ℒ, q[t]] == Subscript[τ, q], {q, {Subscript[ϕ, 1], Subscript[ϕ, 2]}}]shaft = StateSpaceModel[eqns, {Subscript[ϕ, 1][t], Subscript[ϕ, 2][t], Derivative[1][Subscript[ϕ, 1]][t], Derivative[1][Subscript[ϕ, 2]][t]}, {i[t], Subscript[τ, d][t]}, {Derivative[1][Subscript[ϕ, 1]][t], Derivative[1][Subscript[ϕ, 2]][t]}, t, IconizedObject[«labels»]]The state response of a numerical model to an input torque from the motor:
StateResponse[shaft /. IconizedObject[«pars»], {5UnitBox[t], 0}, {t, 0, 25}];Plot[%, {t, 0, 25}, PlotRange -> All, PlotLegends -> {Subscript[ϕ, 1], Subscript[ϕ, 2], Subscript[ϕ, 1]', Subscript[ϕ, 2]'}]Compute an approximate discrete-time state-space model of a ball and beam system starting from continuous-time equations:
The kinetic energy of the rolling ball, assuming no slipping:
𝒦 = (1/2) m x'[t]^2 + (1/2) ℐ ω[t]^2 /. {ℐ -> (2/5) m Subscript[r, b]^2, ω[t] -> (x'[t]/Subscript[r, b])}Its potential energy, assuming small tilt-angles of the beam:
𝒰 = m g x[t] Sin[α[t]] /. Sin[α[t]] -> α[t] /. α[t] -> (Subscript[r, w]/l) θ[t]ℒ = 𝒦 - 𝒰eqBall = D[D[ℒ, x'[t]], t] - D[ℒ, x[t]] == -b x'[t]The Kirchhoff voltage equation of the tilt-motor, assuming no armature inductance:
kvl = v[t] == r i[t] + k θ'[t];The tilt-motor's equation of motion:
eqMotor = j θ''[t] == τ /. (τ -> k i[t]) /. Solve[kvl, i[t]][[1]]The ball and beam's equations:
eqns = {eqBall, eqMotor}Construct a numerical state-space model of the ball and beam:
ssm = StateSpaceModel[eqns, {x[t], x'[t], θ[t], θ'[t]}, v[t], {x[t]}, t] /. IconizedObject[«pars»]Discretize the model with a sampling period of 50 
:
ssmd = ToDiscreteTimeModel[ssm, τ = 1 / 50, Method -> "ZeroOrderHold"]The displacement 
of the ball due to a nudge while keeping the beam level:
or1 = OutputResponse[{ssm, {0, 0.5}}, 0, t]//SimplifyThe displacement computed using the discrete-time model:
Short[or1D = OutputResponse[{ssmd, {0, 0.5}}, Table[0, n = 250]]]In both models, the ball will stop rolling due to friction:
Show[ListStepPlot[or1D, DataRange -> {0, (n - 1)τ}], Plot[or1, {t, 0, 20}, PlotRange -> All, PlotStyle -> Orange]]An input voltage that tilts the beam back and forth once:
backAndForth = -UnitBox[10 t - 1] + UnitBox[10 t - 2];
Plot[backAndForth, {t, 0, 1}, Exclusions -> None]The displacement 
of the ball due to the tilts:
or2 = OutputResponse[ssm, backAndForth, t]//Simplify//ChopThe displacement computed using the discrete-time model:
Short[or2D = OutputResponse[ssmd, Table[backAndForth, {t, 0, 10, τ}]]]In both models, the ball ends up balanced on a level beam:
Show[ListStepPlot[or2D, DataRange -> {0, 10}], Plot[or2, {t, 0, 10}, PlotRange -> All, PlotStyle -> Orange]]Compute state-space models of a pendulum about various equilibrium positions and compare them:
The sinusoidal term makes the model nonlinear:
eqn = θ''[t] + (b/m)θ'[t] + (g/l)Sin[θ[t]] == 0;The equilibrium positions of the pendulum are vertically downward and upward:
eqs = Solve[ 0 <= Θ < 2 π && eqn /. {θ[t] -> Θ, Derivative[_][_][t] :> 0}, Θ]A state-space model of the pendulum linearized around a generic equilibrium value 
:
ssm = StateSpaceModel[eqn, {{θ[t], Θ}, θ'[t]}, {}, θ[t], t, IconizedObject[«labels»]]The state-space models around the two equilibrium positions for a set of parameter values:
{ssm0, ssm180} = ssm /. eqs /. IconizedObject[«pars»]The response of the model linearized around 0 is stable, while the one around 180° is unstable:
Table[Plot[Evaluate@OutputResponse[{sys, {0.1, 0}}, {}, {t, 0, 20}], {t, 0, 20}, IconizedObject[«plotOpts»]], {sys, {ssm0, ssm180}}]This is because the two equilibrium points have stable and unstable eigenvalues:
Eigenvalues[First[Normal[#]]]& /@ {ssm0, ssm180}Compute the state-space model of a Wilberforce pendulum that has coupled dynamics and compare the efficacy of different inputs on the pendulum:
eqns = {k z[t] + (1/2) ε θ[t] + m Derivative[2][z][t] == f[t], (1/2) ε z[t] + δ θ[t] + ℐ Derivative[2][θ][t] == τ[t]};A set of numerical values for the parameters:
pars = {m -> 0.05, ℐ -> 6.281 , δ -> 0.75, ε -> 0.8, k -> 1.2};Construct a state-space model of the system:
wPend = StateSpaceModel[eqns /. pars, {z[t], θ[t]}, {f[t], τ[t]}, {z[t], θ[t]}, t, IconizedObject[«labels»]]Its output response reveals the coupled dynamics between 
and 
:
OutputResponse[{wPend, {0, 0, 0.1, 0}}, {0, 0}, {t, 0, 30}];
Plot[%, {t, 0, 30}, PlotRange -> All, PlotLegends -> {z, θ}]The system is independently controllable with either the force 
or torque 
:
Table[ControllableModelQ[SystemsModelExtract[wPend, i]], {i, {1, 2}}]A system specification where 
is the sole feedback input:
sspecf = <|"InputModel" -> wPend, "FeedbackInputs" -> 1|>;And one where the torque 
is the sole feedback input:
sspecτ = <|"InputModel" -> wPend, "FeedbackInputs" -> 2|>;A pole placement controller to damp the oscillations for each system:
{𝒸𝒹f, 𝒸𝒹τ} = Table[StateFeedbackGains[sspec, {-2, -3, -3.5, -4}, "Data"], {sspec, {sspecf, sspecτ}}]Obtain the closed-loop systems:
{csysf, csysτ} = Table[𝒸𝒹["ClosedLoopSystem"], {𝒸𝒹, {𝒸𝒹f, 𝒸𝒹τ}}]//ChopThe longitudinal oscillations 
are damped more effectively by the torque 
:
{srf, srτ} = Table[StateResponse[{csys, {0, 0, 0.2, 0}}, {0, 0}, {t, 0, 8}], {csys, {csysf, csysτ}}];Plot[Evaluate@{srf[[1]], srτ[[1]]}, {t, 0, 8}, IconizedObject[«plotOpts»]]The rotational oscillations are damped more effectively by the force 
:
Plot[Evaluate@{srf[[3]], srτ[[3]]}, {t, 0, 8}, IconizedObject[«plotOpts»]]Obtain the feedback gains of each model:
{κf, κτ} = Table[𝒸𝒹["FeedbackGains"], {𝒸𝒹, {𝒸𝒹f, 𝒸𝒹τ}}]It takes less effort to dampen the oscillations using 
:
Plot[{-κf.srf, -κτ.srτ}, {t, 0, 6}, PlotRange -> All, PlotLegends -> {f, τ}]This can also be seen by quantifying the control effort:
NIntegrate[Abs[#], {t, 0, 6}]& /@ {-κf.srf, -κτ.srτ}Compute the state-space model of a lathe's cutting process. The delays in the model are necessary to capture the chattering behavior of the system:
A model of the lathe's cutting process:
eqn = m x''[t] + c x'[t] + k x[t] == -α (u[t] + x[t] - x[t - τ]) /. τ -> (2 π/ω);lathe = StateSpaceModel[eqn, {x[t], x'[t]}, u[t], x[t], t, IconizedObject[«labels»]] /. {m -> 3, k -> 1000, ω -> 33, α -> 30, c -> 1}The chattering can be seen in the delay model:
OutputResponse[lathe, 0.01UnitStep[t], {t, 0, 60}];
Plot[%, {t, 0, 60}, PlotRange -> All]Obtain a delay-free approximation:
dfSys = SystemsModelDelayApproximate[lathe, 0]But the delay-free model does not capture the same chattering:
OutputResponse[dfSys, 0.01UnitStep[t], {t, 0, 60}];
Plot[%, {t, 0, 60}, PlotRange -> All]State-space models allow for state-feedback control techniques like pole placement. Place the poles of the inverted pendulum on the left-hand side of the 
-plane to balance the pendulum: »
pend = StateSpaceModel[{{{0, 1, 0, 0}, {0, -0.3, 9.81, -0.02}, {0, 0, 0, 1}, {0, -0.3, 58.86, -0.12}},
{{0}, {2.}, {0}, {2.}}, {{1, 0, 0, 0}, {0, 0, 1, 0}}, {{0}, {0}}},
{{x[t], 0}, Subscript[, 1], {θ[t], 0},
Subscript[, 2]}, {{f[t], 0}}, Automatic, t,
SamplingPeriod -> None, SystemsModelLabels -> {f, {f, f},
{x, θ, x, Derivative[1][x]}}];A controller that balances the pendulum using a set of closed-loop poles:
clPoles = {-2 + I / 10, -2 - I / 10, -5, -3};
𝒸𝒹 = StateFeedbackGains[pend, clPoles, "Data"]The closed-loop system balances the pendulum when the cart is disturbed:
sr = StateResponse[𝒸𝒹["ClosedLoopSystem"], UnitBox[4t - 1], {t, 0, 8}];
Plot[Evaluate@%[[{1, 3}]], {t, 0, 8}, PlotRange -> All, PlotLegends -> {x, θ}]𝒸𝒹["ClosedLoopPoles"]Plot[-𝒸𝒹["FeedbackGains"].sr, {t, 0, 8}, PlotRange -> All]State-space models are the basis for computing optimal state feedback gains that minimize a cost function. Dampen the oscillations of a flexible shaft using optimal control: »
shaft = StateSpaceModel[{{{0., 0., 1., 0.}, {0., 0., 0., 1.}, {-0.875, 0.875, -1.275, 0.425},
{0.175, -0.175, 0.085, -0.255}}, {{0., 0.}, {0., 0.}, {0.5, 0.}, {0., 0.1}},
{{0., 0., 1., 0.}, {0., 0., 0., 1.}}, {{0., 0.}, {0., 0.}}},
{{Subscript[ϕ, 1][t], 0.},
{Subscript[ϕ, 2][t], 0.}, Subscript[, 1], Subscript[, 2]},
{{i[t], 0.}, {Subscript[τ, d][
t], 0.}}, Automatic, t, SamplingPeriod -> None,
SystemsModelLabels -> {{i, Subscript[τ, d]},
{Derivative[1][Subscript[ϕ, 1]], Derivative[1][Subscript[ϕ, 2]]},
{Subscript[ϕ, 1], Subscript[ϕ, 2],
Derivative[1][Subscript[ϕ, 1]], Derivative[1][Subscript[ϕ, 2]]}}];Set the input current 
as the sole feedback input:
sspec = <|"InputModel" -> shaft, "FeedbackInputs" -> 1|>;A set of state and control weight matrices 
and 
:
{q, r} = {DiagonalMatrix[{1, 5, 1, 20}], {{1}}}Compute the optimal controller that minimizes the cost function 
:
lqr = LQRegulatorGains[sspec, {q, r}, "Data"]The oscillations are damped by the controller:
OutputResponse[shaft, {0, UnitBox[t]}, {t, 0, 15}];
Plot[%, {t, 0, 15}, PlotRange -> All]κ = lqr["FeedbackGains"]StateResponse[shaft, {0, UnitBox[t]}, {t, 0, 15}];
Plot[-κ.%, {t, 0, 15}, PlotRange -> All]State-space models are also used to solve tracking problems. Design a controller that tracks the position of a ball on a beam: »
bbm = StateSpaceModel[{{{1., 0.019580419580419582, -0.00003971827153855873, -2.8668998517528657*^-7},
{0., 0.958041958041958, -0.003971827153855872, -0.00002866899851752865},
{0., 0., 1., 0.0144361763022324}, {0., 0., 0., 0.4436176302232399}},
{{-0.000010230808352805627}, {-0.0010230808352805626}, {0.5151688609044076},
{51.516886090440764}}, {{0.02, 0.00019580419580419583, -3.971827153855873*^-7,
-2.8668998517528657*^-9}, {0., 0., 0.02, 0.000144361763022324}},
{{-1.0230808352805628*^-7}, {0.005151688609044076}}},
{{x[], 0}, Subscript[, 1], {θ[], 0}, Subscript[, 2]},
{{v[], 0}}, Automatic, , SamplingPeriod -> 1/50,
SystemsModelLabels -> {v, {v, x},
{θ, x, Derivative[1][x], θ}}];Set the system specification to track the ball's position:
sspec = <|"InputModel" -> bbm, "TrackedOutputs" -> 1|>;A set of state and control weight matrices 
and 
:
{q, r} = {(| | | | | |
| --- | -- | -- | -- | --- |
| 100 | 0 | 0 | 0 | 0 |
| 0 | 10 | 0 | 0 | 0 |
| 0 | 0 | 50 | 0 | 0 |
| 0 | 0 | 0 | 10 | 0 |
| 0 | 0 | 0 | 0 | 500 |), {{0.5}}};Compute the tracking controller:
𝒸𝒹 = LQRegulatorGains[sspec, {q, r}, "Data"]Obtain the closed-loop system:
csys = 𝒸𝒹["ClosedLoopSystem"]The closed-loop system places the ball in the middle of the beam:
tSig = Table[l / 2, n = 10^3] /. {l -> 0.65};or = OutputResponse[{𝒸𝒹["ClosedLoopSystem"], {0, 0.75, 0, 0}}, tSig];
ListStepPlot[or, DataRange -> {0, (n - 1) 1 / 50}, IconizedObject[«plotOpts»]]cm = 𝒸𝒹["ControllerModel"]sr = StateResponse[{𝒸𝒹["ClosedLoopSystem"], {0, 0.75, 0, 0}}, tSig];
cinps = Join[{tSig}, or[[{1}]], sr[[1 ;; 4]]];ListStepPlot[OutputResponse[cm, cinps], IconizedObject[«plotOpts»]]Aerospace Systems (6)
State-space model are useful in modeling aerospace systems. Construct a state-space model of a satellite's attitude dynamics starting from Euler's equations of motion:
Euler's equations with principal moments of inertia 
, 
, 
:
eqns = Table[Subscript[j, i[[1]]] Subscript[ω, i[[1]]]'[t] - (Subscript[j, i[[2]]] - Subscript[j, i[[3]]])Subscript[ω, i[[2]]][t]Subscript[ω, i[[3]]][t] == Subscript[τ, i[[1]]][t], {i, {{x, y, z}, {y, z, x}, {z, x, y}}}] /. {Subscript[j, x] -> 300, Subscript[j, y] -> 320, Subscript[j, z] -> 270}opPt = {Subscript[ω, x0] -> (1/30Sqrt[3]), Subscript[ω, y0] -> (3Sqrt[3]/100), Subscript[ω, z0] -> (3Sqrt[3]/200), Subscript[τ, x0] -> -(27/400), Subscript[τ, y0] -> (3/200), Subscript[τ, z0] -> (1/50)};The operating point is an equilibrium point:
eqns /. Derivative[_][_][t] :> 0 /. IconizedObject[«opPtRules»] /. opPtConstruct a state-space model:
ssm = StateSpaceModel[eqns, IconizedObject[«states»], IconizedObject[«inps»], IconizedObject[«outs»], t, IconizedObject[«labels»]] /. opPtThe satellite's attitude is unregulated if disturbed:
OutputResponse[{ssm, {0.2, -0.1, 0.35}}, {0, 0, 0}, {t, 0, 3000}];
Plot[%, {t, 0, 3000}, PlotRange -> All, PlotLegends -> {Subscript[ω, x], Subscript[ω, y], Subscript[ω, z]}]Verify the controllability of the model:
ControllableModelQ[ssm]State-space models are used in model analysis. Construct a state-space model of a Harrier VTOL jet and assess its controllability:
𝒯 = (1/2)m x'[t]^2 + (1/2)m y'[t]^2 + (1/2)j θ'[t]^2𝒱 = m g y[t]ℒ = 𝒯 - 𝒱{Subscript[f, x], Subscript[f, y], Subscript[f, θ]} = D[(Subscript[f, 1][t]Cos[θ[t]] - Subscript[f, 2][t]Sin[θ[t]] - c x'[t])δx + (Subscript[f, 1][t]Sin[θ[t]] + Subscript[f, 2][t]Cos[θ[t]] - c y'[t])δy + r Subscript[f, 1][t]δθ, {{δx, δy, δθ}}]eqns = Table[Subscript[∂, t]D[ℒ, q'[t]] - D[ℒ, q[t]] == Subscript[f, q], {q, {x, y, θ}}]eqns /. {Derivative[_][_][_] :> 0, θ[t] -> 0};
eqlPos = Solve[%, {Subscript[f, 1][t], Subscript[f, 2][t]}][[1]]ssm = StateSpaceModel[eqns, {x[t], y[t], θ[t]}, eqlPos, {x[t], y[t], θ[t]}, t, IconizedObject[«labels»]]ssmn = ssm /. IconizedObject[«pars»]//NBoth inputs are needed for the aircraft to be fully controllable:
Table[in -> ControllableModelQ@SystemsModelExtract[ssmn, in], {in, {1, 2, All}}]State-space models are useful for the analysis of MIMO systems where multiple inputs affect a given output. Use the state-space model representation to compare the effectiveness of the aileron and the rudder on the yaw dynamics of a Boeing 747 using state feedback control:
A state-space model of the aircraft's lateral motion from a set of state, input and output matrices:
{a, b, c} = {(| | | | |
| ------- | ------- | ------- | ----- |
| -0.0558 | -8.3561 | 0 | -32.2 |
| 0.598 | -0.115 | -0.0318 | 0 |
| -3.05 | 0.388 | -0.465 | 0 |
| 0 | 0 | 1 | 0 |), (| | |
| ------- | ------ |
| 0.00729 | 0.0355 |
| -0.475 | 0.662 |
| 0.153 | 0.801 |
| 0 | 0 |), (| | | | |
| - | - | - | - |
| 0 | 1 | 0 | 0 |
| 0 | 0 | 0 | 1 |)};ssm = StateSpaceModel[{a, b, c}, IconizedObject[«labels»]]Obtain a state-space model with the rudder and another with aileron as the sole input:
{ssmR, ssmA} = Table[SystemsModelExtract[ssm, i], {i, 2}]The closed-loop systems of both systems with an LQR controller:
wts = {DiagonalMatrix[{5, 15, 1, 5}], {{1}}};{csysA, csysR} = Table[LQRegulatorGains[sys, wts, "ClosedLoopSystem"], {sys, {ssmR, ssmA}}]Using the rudder results in a faster yaw response:
or = Table[OutputResponse[{sys, {0, 0.15, 0, 0}}, 0, {t, 0, 6}], {sys, {csysR, csysA}}];
Plot[Evaluate[First /@ or], {t, 0, 6}, IconizedObject[«plotOpts»]]As well as a smaller roll angle:
Plot[Evaluate[Last /@ or], {t, 0, 6}, IconizedObject[«plotOpts»]]State-space models are useful for the design of discrete-time state feedback controllers. Obtain a state-space model of the 747's longitudinal dynamics and improve its handling qualities using discrete-time state-feedback control:
A nonlinear model of the aircraft's longitudinal dynamics:
longEqns = {Derivative[1][u][t] == -q[t] Subscript[w, 0] + Subscript[𝒳, u] u[t] + Subscript[𝒳, w] w[t] - g Cos[Subscript[θ, 0]] θ[t] + Subscript[𝒳, δe] Subscript[δ, e][t], Derivative[1][w][t] == q[t] Subscript[u, 0] + Subscript[𝒵, u] u[t] + Subscript[𝒵, w] w[t] - g Sin[Subscript[θ, 0]] θ[t] + Subscript[𝒵, δe] Subscript[δ, e][t], Derivative[1][q][t] == q[t] Subscript[ℳ, q] + Subscript[ℳ, u] u[t] + Subscript[ℳ, w] w[t] + Subscript[ℳ, δe] Subscript[δ, e][t], Derivative[1][θ][t] == q[t]};A linearized state-space model:
ssm = StateSpaceModel[longEqns /. IconizedObject[«pars»], {u[t], w[t], θ[t], q[t]}, Subscript[δ, e][t], θ[t], t, IconizedObject[«labels»]]Its response to an initial perturbation in the pitch angle 
is sluggish and oscillatory:
OutputResponse[{ssm, {0, 0, 0.3}}, 0, {t, 0, 1800}];
Plot[%, {t, 0, 1800}, PlotRange -> All]This is because the eigenvalues of the linear system are close to the imaginary axis:
Eigenvalues[First[Normal@ssm]]A set control weights and sampling period:
wts = {DiagonalMatrix[{1, 1, 250, 50}], {{0.25}}};τ = 0.5;Compute the optimal controller that minimizes an approximated discrete-time cost function:
dlqr = DiscreteLQRegulatorGains[ssm, wts, τ, "Data"]The discrete-time closed-loop system:
dcsys = dlqr["DiscreteTimeClosedLoopSystem"]The handling qualities are improved:
n = 120;
sr = StateResponse[{dcsys, {0, 0, 0.1}}, Table[0, n]];
ListStepPlot[%[[3]], DataRange -> {0, (n - 1)τ}, PlotRange -> All]ListStepPlot[-dlqr["FeedbackGains"].sr, DataRange -> {0, (n - 1)τ}, PlotRange -> All]Discrete-time controllers can also be designed by approximating the continuous-time models. Design a discrete-time controller to stabilize a Harrier VTOL jet by approximating its continuous-time state-space model: »
A state-space model of the Harrier's horizontal dynamics:
ssm = StateSpaceModel[{{{0., 1., 0., 0., 0., 0.}, {0., -6.25*^-6, 0., 0., -9.8, 0.},
{0., 0., 0., 1., 0., 0.}, {0., 0., 0., -6.25*^-6, 0., 0.}, {0., 0., 0., 0., 0., 1.},
{0., 0., 0., 0., 0., 0.}}, {{0., 0.}, {0.000125, 0.}, {0., 0.}, {0., 0.000125}, {0., 0.},
{526.3157894736843, 0.}}, {{1., 0., 0., 0., 0., 0.}, {0., 0., 1., 0., 0., 0.},
{0., 0., 0., 0., 1., 0.}}, {{0., 0.}, {0., 0.}, {0., 0.}}},
{{x[t], 0.}, Subscript[, 1][t],
{y[t], 0.}, Subscript[, 2][t],
{θ[t], 0.}, Subscript[, 3][t]},
{{Subscript[f, 1][t], 0.},
{Subscript[f, 2][t], 0.}}, Automatic, t,
SamplingPeriod -> None, SystemsModelLabels ->
{{Subscript[f, 1], Subscript[f, 2]},
{x, y, θ},
{x, Derivative[1][x], y, Derivative[1][y],
θ, Derivative[1][θ]}}];Discretize the model with a sampling period of 
:
dssm = ToDiscreteTimeModel[ssm, τ = 0.15]//ChopWithout a controller, the jet's horizontal position is unregulated if its pitch is disturbed:
OutputResponse[{dssm, {0, 0, 0, 0, 0.1}}, Table[{0, 0}, 20]];
ListStepPlot[%[[1]], DataRange -> {0, 19τ}, PlotRange -> All]Design a discrete-time state feedback controller to stabilize the jet:
clp = {0.9, -0.95, 0.8, 0.6, -0.75, 0.45};𝒸𝒹 = StateFeedbackGains[dssm, clp, "Data"]The discrete-time controller model:
𝒸𝒹["ControllerModel"]csys = 𝒸𝒹["ClosedLoopSystem"]The jet is stabilized with respect to an initial disturbance by the controller:
OutputResponse[{csys, {0, 0, 0, 0, 0.25}}, Table[{0, 0}, 100]];
ListStepPlot[%, DataRange -> {0, 100τ}, IconizedObject[«plotOpts»]]State-space models can also be used for the design of output feedback controllers such as the estimator regulator. Design an estimator regulator that tracks the angular rate required for a satellite to maintain its nadir-pointing orientation using a discrete-time model: »
sat = StateSpaceModel[{{{0., 0.004330127018922193, 0.008660254037844387},
{-0.0024356964481437333, 0., -0.0018042195912175809}, {-0.0038490017945975057,
-0.0014255562202212984, 0.}}, {{0.0033333333333333335, 0., 0.}, {0., 0.003125, 0.},
{0., 0., 0.003703703703703704}}, {{1., 0., 0.}, {0., 1., 0.}, {0., 0., 1.}},
{{0., 0., 0.}, {0., 0., 0.}, {0., 0., 0.}}},
{{Subscript[ω, x][t], 0.},
{Subscript[ω, y][t], 0.},
{Subscript[ω, z][t], 0.}},
{{Subscript[τ, x][t], 0.},
{Subscript[τ, y][t], 0.},
{Subscript[τ, z][t], 0.}}, Automatic, t,
SamplingPeriod -> None, SystemsModelLabels ->
{{Subscript[τ, x], Subscript[τ, y],
Subscript[τ, z]}, {Subscript[ω, x],
Subscript[ω, y], Subscript[ω, z]},
{Subscript[ω, x], Subscript[ω, y],
Subscript[ω, z]}}];Discretize the model with a sampling period of 0.3:
dsat = ToDiscreteTimeModel[sat, 0.3]The radius and gravitational constant mass product of the Earth:
{𝓇, Subscript[μ, ]} = Entity["Planet", "Earth"][{"Radius", "GravitationalConstantMassProduct"}]The semimajor axis of the satellite's circular orbit for an altitude of 470 km:
𝒶 = UnitConvert[𝓇, "Meters"] + UnitConvert[Quantity[470, "Kilometers"], "Meters"]The orbital period is around 94 minutes:
Τ = 2πSqrt[(𝒶^3/Subscript[μ, ])];
UnitConvert[Τ, "Minutes"]The angular rate is the number of degrees over the orbital period:
angRate = (2π/QuantityMagnitude[Τ])Set the system specification to track the satellite's angular rate in the 
direction:
sspec = <|"InputModel" -> dsat, "TrackedOutputs" -> 1|>;Compute a set of estimator gains:
ℓ = EstimatorGains[sspec, {-0.75, 0.5, -0.25}]And a state-feedback controller:
κ = StateFeedbackGains[sspec, {-0.2, -0.4, -0.3, -0.5}, "Data"]Assemble the estimator regulator:
ℯ𝓇 = EstimatorRegulator[sspec, {ℓ, κ}, "Data"]csys = ℯ𝓇["ClosedLoopSystem"]//ChopThe satellite now tracks the required angular rate to keep its nadir-pointing orientation:
or = OutputResponse[{csys, {0, 0.75}}, Table[angRate, 30]];
Grid[{Table[ListStepPlot[%[[i]], DataRange -> {0, 29 0.3}, IconizedObject[«plotOpts»]], {i, 3}]}]cm = ℯ𝓇["ControllerModel"]or = OutputResponse[cm, IconizedObject[«cinps»]];
Grid[{Table[ListStepPlot[%[[i]], DataRange -> {0, 29 0.3}, IconizedObject[«plotOpts»]], {i, 3}]}]Biological Systems (2)
Symbolic state-space models can be used to simulate models with parameters. Construct a state-space model of the metabolism of a drug and simulate it:
A model the drug's concentrations 
and 
in the GI tract and bloodstream:
eqns = {Subscript[c, 1]'[t] == -Subscript[k, 1]Subscript[c, 1][t] + u[t], Subscript[c, 2]'[t] == Subscript[k, 1]Subscript[c, 1][t] - Subscript[k, 2]Subscript[c, 2][t]};ssm = StateSpaceModel[eqns, {Subscript[c, 1][t], Subscript[c, 2][t]}, u[t], Subscript[c, 2][t], t, IconizedObject[«labels»]]The analytical expression of its output response to a constant ingestion rate:
or = OutputResponse[ssm, UnitStep[t], t]//SimplifyPlot the response for different values for the constants 
and 
:
{{0.2, 0.3, 0.4}, {0.05, 0.1, 0.15}}Map[or /. {Subscript[k, 1] -> #[[1]], Subscript[k, 2] -> #[[2]]}&, {{0.2, 0.05}, {0.3, 0.1}, {0.4, 0.15}}];
Plot[%, {t, 0, 100}, IconizedObject[«plotOpts»]]State-space models can be used in the design of observers. Starting from an HIV infection model, design an estimator to estimate the free virus population:
eqns = {𝒯'[t] == 𝓈 - 𝒹 𝒯[t] - (1 - Subscript[𝓊, 1][t])β 𝒯[t]𝓋[t], Subscript[𝒯, †]'[t] == (1 - Subscript[𝓊, 1][t])β 𝒯[t]𝓋[t] - μ Subscript[𝒯, †][t], 𝓋'[t] == (1 - Subscript[𝓊, 2][t])𝓀 Subscript[𝒯, †][t] - 𝒸 𝓋[t]};Its equilibrium points and parameter values:
eqlpts = {Subscript[𝒯, 0] -> (𝒸 μ/𝓀 β), Subscript[𝒯, †0] -> (𝓀 𝓈 β - 𝒸 𝒹 μ/𝓀 β μ), Subscript[𝓋, 0] -> (𝓀 𝓈 β - 𝒸 𝒹 μ/𝒸 β μ)};pars = {𝒹 -> 0.02, 𝓀 -> 100, 𝓈 -> 10, β -> 0.000024, 𝒸 -> 2.4, μ -> 0.24};ssm = StateSpaceModel[eqns, IconizedObject[«opPts»], {Subscript[𝓊, 1][t], Subscript[𝓊, 2][t]}, {Subscript[𝒯, †][t], 𝓋[t]}, t, IconizedObject[«labels»]] /. eqlpts /. parsassm = AffineStateSpaceModel[eqns, IconizedObject[«ins»], {Subscript[𝓊, 1][t], Subscript[𝓊, 2][t]}, {Subscript[𝒯, †][t], 𝓋[t]}, t] /. eqlpts /. parsℓ = EstimatorGains[ssm, {-11, -12, -8}];
est = StateOutputEstimator[ssm, ℓ]Compare the nonlinear model's free virus population to the estimated virus population:
or = OutputResponse[{assm, {1000, 0, 10}}, {0.15, 0.3}, {t, 0, 500}];
orest = OutputResponse[est, Join[{0.15, 0.3}, or], {t, 0, 500}];
Plot[{or[[2]], orest[[3]]}, {t, 0, 500}, IconizedObject[«plotOpts»]]Chemical Systems (3)
State-space models are useful for modeling chemical reaction processes. Construct a state-space model of a fermentation process and simulate its response to an exponential decay in the dilution rate:
A model of the fermentation process:
eqns = {Subscript[c, 1]'[t] == (Subscript[c, 10] Subscript[k, m] Subscript[μ, m]/(Subscript[c, 20] + Subscript[k, m])^2)Subscript[c, 2][t] - Subscript[c, 10]u[t], Subscript[c, 2]'[t] == -(Subscript[c, 20] Subscript[μ, m]/y (Subscript[c, 20] + Subscript[k, m]))Subscript[c, 1][t] - ((Subscript[c, 10] Subscript[k, m] Subscript[μ, m]/y (Subscript[c, 20] + Subscript[k, m])^2) + (Subscript[c, 20] Subscript[μ, m]/Subscript[c, 20] + Subscript[k, m]))Subscript[c, 2][t] + (Subscript[c, 10]/y)u[t]};ferm = StateSpaceModel[eqns, {Subscript[c, 1][t], Subscript[c, 2][t]}, u[t], {Subscript[c, 1][t], Subscript[c, 2][t]}, t, IconizedObject[«labels»]]fermN = ferm /. {Subscript[c, 10] -> 10, Subscript[c, 20] -> 5, Subscript[k, m] -> 0.05, Subscript[μ, m] -> 0.4, y -> 0.4}An exponential decay in the dilution rate 
leads to the halting of the fermentation process:
OutputResponse[fermN, 0.1E^-0.2t, {t, 0, 400}];
Plot[%, {t, 0, 400}, IconizedObject[«plotOpts»]]State-space models are ideal for modeling the chemical dynamics of a continuously stirred-tank reactor (CSTR). Construct a state-space model for the polymerization of methyl methacrylate (MMA):
eqns = {Subscript[ζ, 1]'[t] == 18 - 3Subscript[ζ, 1][t] - 1.36594Subscript[ζ, 1][t]Sqrt[Subscript[ζ, 2][t]], Subscript[ζ, 2]'[t] == 60μ[t] - 3.03161Subscript[ζ, 2][t], Subscript[ζ, 3]'[t] == -0.00134106Subscript[ζ, 1][t]Sqrt[Subscript[ζ, 2][t]] + 0.034677Subscript[ζ, 2][t] - 10Subscript[ζ, 3][t], Subscript[ζ, 4]'[t] == 136.758Subscript[ζ, 1][t]Sqrt[Subscript[ζ, 2][t]] - 10Subscript[ζ, 4][t]};eqlpts = {Subscript[ζ, 10] -> 4.7529, Subscript[ζ, 20] -> 0.3321, Subscript[ζ, 30] -> 0.00078, Subscript[ζ, 40] -> 37.4581, Subscript[μ, 0] -> 0.01678};ssm = StateSpaceModel[eqns, IconizedObject[«opPts»], {{μ[t], Subscript[μ, 0]}}, {Subscript[ζ, 1][t], Subscript[ζ, 3][t]}, t, IconizedObject[«labels»]] /. eqlptsIts poles are on the left side of the 
plane, indicating the model is stable:
PoleZeroPlot[ssm]The MMA concentration decreases due to an increase in the initiator volumetric flow, indicating PMMA synthesis:
OutputResponse[{ssm, {10^4, 5 10^2}}, UnitStep[t], {t, 0, 5}];
Table[Plot[%[[i]], {t, 0, 5}, IconizedObject[«plotOpts»]], {i, 2}]State-space models can be used to model systems with delays. Obtain a state-space model for a distillation column from its Wood–Berry transfer function model and compare its response to a delay-free approximation of the same model:
The Wood–Berry transfer function model of the distillation column:
dColumnTFM = TransferFunctionModel[{{{12.8/E^s, -18.9/E^(3*s),
3.8/E^((81*s)/10)}, {6.6/E^(7*s), -19.4/E^(3*s),
4.9/E^((17*s)/5)}}, {{1. + 16.7*s, 1. + 21.*s,
1. + 14.9*s}, {1. + 10.9*s, 1. + 14.4*s,
1. + 13.2*s}}}, s, SystemsModelLabels ->
{{Subscript[u, s], Subscript[u, r],
Subscript[u, f]}, {Subscript[y, d],
Subscript[y, b]}, Automatic}];dColumnSSM = StateSpaceModel[dColumnTFM]Its response to a step-input disturbance to the feed is delayed:
or = OutputResponse[dColumnSSM, {0, 0, UnitStep[t]}, {t, 0, 60}];
Plot[or, {t, 0, 60}, IconizedObject[«plotOpts»]]Obtain a delay-free approximation of the model:
dFreeSys = SystemsModelDelayApproximate[dColumnSSM, 0]The delay and delay-free system's responses to a disturbance in the feed input:
orDF = OutputResponse[dFreeSys, {0, 0, UnitStep[t]}, {t, 0, 60}];Grid[{Plot[#, {t, 0, 60}, IconizedObject[«plotOpts»]]& /@ Thread[{or, orDF}]}]Electrical Systems (4)
Construct a state-space model of a DC motor with armature and field voltage inputs and analyze its controllability:
eqns = {Subscript[v, a][t] == Subscript[r, a]Subscript[i, a][t] + Subscript[l, a] Derivative[1][Subscript[i, a]][t] + Subscript[k, b] ω[t] Subscript[i, f][t], Subscript[v, f][t] == Subscript[r, f] Subscript[i, f][t] + Subscript[l, f] Derivative[1][Subscript[i, f]][t], j Derivative[1][ω][t] == Subscript[k, t] Subscript[i, a][t] Subscript[i, f][t] + Subscript[𝒯, d][t] - b ω[t]};varEqlPts = {Subscript[i, a][t] -> (Subscript[r, f] (b Subscript[r, f] Subscript[v, a0] - Subscript[k, b] Subscript[v, f0] Subscript[𝒯, 0])/b Subscript[r, a] Subsuperscript[r, f, 2] + Subscript[k, b] Subscript[k, t] Subsuperscript[v, f0, 2]), Subscript[i, f][t] -> (Subscript[v, f0]/Subscript[r, f]), ω[t] -> (Subscript[r, f] (Subscript[k, t] Subscript[v, a0] Subscript[v, f0] + Subscript[r, a] Subscript[r, f] Subscript[𝒯, 0])/b Subscript[r, a] Subsuperscript[r, f, 2] + Subscript[k, b] Subscript[k, t] Subsuperscript[v, f0, 2])};inpEqlPts = {Subscript[v, a][t] -> Subscript[v, a0], Subscript[v, f][t] -> Subscript[v, f0], Subscript[𝒯, d][t] -> Subscript[𝒯, 0]};eqns /. Derivative[_][_][t] :> 0 /. inpEqlPts//Simplifydcm = StateSpaceModel[eqns, varEqlPts, inpEqlPts, ω[t], t, IconizedObject[«labels»]]The field voltage 
is necessary to control the motor:
Table[ControllableModelQ[SystemsModelExtract[dcm, j]], {j, 2}]Symbolic state-space models can be used to simulate models with parameters. Construct a symbolic state-space model of an operational amplifier (op amp) circuit from its governing equations and analyze its output phase and amplitude with different parameter values:
The governing equations using Kirchhoff's current law (KCL):
eqns = {(Subscript[v, in][s] - Subscript[v, 1][s]/Subscript[r, 1]) + (0 - Subscript[v, 1][s]/Subscript[r, a]) + (0 - Subscript[v, 1][s]/1 / (s Subscript[c, 1])) == 0, (Subscript[v, 1][s] - 0/Subscript[r, a]) + (Subscript[v, 2][s] - 0/Subscript[r, b]) == 0, (Subscript[v, 2][s] - Subscript[v, out][s]/Subscript[r, 2]) + (0 - Subscript[v, out][s]/1 / (s Subscript[c, 2])) == 0};tfm = TransferFunctionModel[(Subscript[v, out][s]/Subscript[v, in][s]) /. Solve[%, {Subscript[v, out][s], Subscript[v, 1][s], Subscript[v, 2][s]}], s]ssm = StateSpaceModel[tfm]Obtain two state-space models with different values for 
and 
:
{ssm1, ssm2} = ssm /. {{Subscript[c, 1] -> 10^-6, Subscript[c, 2] -> 10^-3}, {Subscript[c, 1] -> 10^-7, Subscript[c, 2] -> 10^-5}} /. IconizedObject[«pars»]//NThe first set of capacitance values attenuates the input:
OutputResponse[ssm1, Sin[3 t], {t, 0, 30}];
Plot[{Sin[3t], %}, {t, 0, 10}, IconizedObject[«plotOpts»]]The second set inverts the input:
OutputResponse[ssm2, Sin[3 t], {t, 0, 30}];
Plot[{Sin[3t], %}, {t, 0, 10}, IconizedObject[«plotOpts»]]State-space models can represent systems with a mix of differential and algebraic equations. Construct a descriptor state-space model of an RLC circuit from its differential equations and a standard state-space model from its differential equations:
The equations of the individual components:
eqns = {Subscript[v, l][t] == l i'[t], Subscript[v, r][t] == r i[t], Subscript[v, c]'[t] == i[t] / c};kirchhoff = {Subscript[v, l][t] + Subscript[v, c][t] + Subscript[v, r][t] == Subscript[v, s][t]};A descriptor state-space model is obtained because the Kirchhoff equation is algebraic:
ssmd = StateSpaceModel[Join[eqns, kirchhoff], {i[t], Subscript[v, l][t], Subscript[v, c][t], Subscript[v, r][t]}, Subscript[v, s][t], {i[t], Subscript[v, l][t], Subscript[v, c][t], Subscript[v, r][t]}, t, DescriptorStateSpace -> True]The circuit's response to an AC voltage:
ord = OutputResponse[ssmd /. IconizedObject[«pars»], 5 Sin[100t], {t, 0, 0.2}];
Table[Plot[ℴ𝓇[[1]], {t, 0, 0.2}, IconizedObject[«plotOpts»]], {ℴ𝓇, ({%, {i, Subscript[v, l], Subscript[v, c], Subscript[v, r]}})}]Using purely differential equations, a standard state-space model is obtained:
ssm = StateSpaceModel[l q''[t] + r q'[t] + q[t] / c == Subscript[v, s][t], {q[t], q'[t]}, Subscript[v, s][t], {q'[t], l q''[t], Subscript[v, s][t] - r q'[t] - l q''[t], r q'[t]}, t, IconizedObject[«labels»]]TransferFunctionModel[ssmd][s] - TransferFunctionModel[ssm][s]State-space models are used for solving tracking problems. Design an estimator-based tracking controller for a DC motor in the presence of varying torque loads and sensor noise: »
dcMot = StateSpaceModel[{{{-222.22222222222223, -100.8308373027916, -305.5555555555556}, {0, -100., 0},
{550., 0.4436776755908005, -1.62}}, {{55.55555555555556, 0, 0}, {0, 50., 0}, {0, 0, 10.}},
{{0, 0, 1}}, {{0, 0, 0}}}, {{Subscript[i, a][t], 0},
{Subscript[i, f][t], 0},
{ω[t], 0}},
{{Subscript[v, a][t], 0},
{Subscript[v, f][t], 0},
{Subscript[𝒯, d][t], 0}}, Automatic, t,
SamplingPeriod -> None, SystemsModelLabels ->
{{Subscript[v, a], Subscript[v, f],
Subscript[𝒯, d]}, ω,
{ω, Subscript[i, a],
Subscript[i, f]}}];The model specification for the controller design:
sspec = <|"InputModel" -> dcMot, "FeedbackInputs" -> {1, 2}, "TrackedOutputs" -> 1|>;Compute a set of estimator gains:
l = EstimatorGains[sspec, {-20, -40, -60}]Compute a state-feedback controller:
k = StateFeedbackGains[sspec, {-249 - 410 I, -249 + 410 I, -272, -21}, "Data"]csys = EstimatorRegulator[sspec, {l, k}, {"ClosedLoopSystem", <|"InputModel" -> dcMot, "NoisyOutputs" -> 1, "Merge" -> False|>}]A noisy signal to simulate the sensor noise:
n = 20;
Subscript[y, v] = Interpolation[{Range[0, n], RandomVariate[IconizedObject[« 2
𝒩[μ,σ ]»], {n + 1}]}, t];Plot[Subscript[y, v], {t, 0, n}]A signal that simulates a varying torque load:
Subscript[u, e] = 0.025 UnitBox[t - 2] - 0.01 UnitBox[t - 4] + 0.02 UnitBox[t - 9] + 0.015 UnitBox[t - 15];Plot[Subscript[u, e], {t, 0, 20}, Exclusions -> None]ref = Sin[2 t];Simulate the system's response:
iord = InputOutputResponse[csys, {Subscript[u, e], ref, Subscript[y, v]}, {t, 0, 20}, "Data"]Its output tracks the reference signal:
Plot[{ref, iord["OutputResponse"]}, {t, 0, 20}, IconizedObject[«plotOpts»]]iord[{"SubsystemOutputResponse", 4}];
Table[Plot[ℴ𝓇[[1]], {t, 0, 20}, IconizedObject[«plotOpts»]], {ℴ𝓇, ({%, {Subscript[v, a], Subscript[v, q]}})}]Information Systems (1)
State-space models can be used to model systems based on difference equations. Compute a state-space model of a webserver's dynamics and simulate its response to the maximum number of requests and keep-alive times:
A difference equation model of the system:
diffEqns = {Subscript[x, cpu][k + 1] == 0.54Subscript[x, cpu][k] - 0.11Subscript[x, mem][k] - 8.5 10^-3Subscript[u, ka][k] + 4.4 10^-4Subscript[u, mr][k], Subscript[x, mem][k + 1] == -0.026Subscript[x, cpu][k] + 0.63Subscript[x, mem][k] - 2.5 10^-4Subscript[u, ka][k] + 2.8 10^-4Subscript[u, mr][k]};ssm = StateSpaceModel[diffEqns, {Subscript[x, cpu][k], Subscript[x, mem][k]}, {Subscript[u, mr][k], Subscript[u, ka][k]}, Subscript[x, cpu][k], k, IconizedObject[«labels»]]A set of values for inputs 
and 
:
Short[inp = Inner[ConstantArray, {{600, 10}, {800, 15}, {450, 5}}, {300, 700, 500}, Join, 1]]Table[ListStepPlot[𝒾𝓃𝓅[[1]], IconizedObject[«plotOpts»]], {𝒾𝓃𝓅, ({inp, {Subscript[u, mr], Subscript[u, ka]}})}]Simulate the system using the input signal:
StateResponse[ssm, inp];
ListStepPlot[%, DataRange -> {0, 1500}, IconizedObject[«plotOpts»]]Random Processes (6)
State-space models can represent random processes. The state-space model of a MAProcess:
StateSpaceModel[MAProcess[{a, b, c}, σ^2]]An ARProcess:
StateSpaceModel[ARProcess[{a, b, c}, σ^2]]An ARMAProcess:
StateSpaceModel[ARMAProcess[{a, b, c}, {d, e}, σ^2]]An ARIMAProcess:
StateSpaceModel[ARIMAProcess[{a, b}, 1, {c, d}, σ^2]]StateSpaceModel[SARIMAProcess[{}, 1, {b}, {2, {c}, 1, {d}}, σ^2]]A SARMAProcess:
StateSpaceModel[SARMAProcess[{a}, {b}, {3, {c}, {d}}, σ^2]]Properties & Relations (20)
The eigenvalues of the state matrix are invariant under a similarity transformation:
ssm = StateSpaceModel[{{{-3, 0}, {0, -2.}}, {{2}, {3}}, {{-1, -2}}, {{0}}}, SamplingPeriod -> None,
SystemsModelLabels -> None];ssmt = StateSpaceTransform[ssm, RandomReal[{-1, 1}, {2, 2}]]Table[Eigenvalues[First[Normal[sys]]], {sys, {ssm, ssmt}}]The transfer function model of state-space models related through a similarity transformation are the same:
ssm = StateSpaceModel[{{{-3, 0}, {0, -2.}}, {{2}, {3}}, {{-1, -2}}, {{0}}}, SamplingPeriod -> None,
SystemsModelLabels -> None];ssmt = StateSpaceTransform[ssm, RandomReal[{-1, 1}, {2, 2}]]The transfer function models are the same:
TransferFunctionModel[ssm][s] - TransferFunctionModel[ssmt][s]The controllability property is generally not invariant under a similarity transformation:
ssm = StateSpaceModel[{{{-3, 0}, {0, -2.}}, {{2}, {0}}, {{-1, -2}}, {{0}}}, SamplingPeriod -> None,
SystemsModelLabels -> None];ssmt = StateSpaceTransform[ssm, (| | |
| -- | -- |
| -1 | -2 |
| 3 | 4 |)]Table[ControllableModelQ[sys], {sys, {ssm, ssmt}}]The observability property is generally not invariant under a similarity transformation:
ssm = StateSpaceModel[{{{-3, 0}, {0, -2.}}, {{2}, {3}}, {{-1, 0}}, {{0}}}, SamplingPeriod -> None,
SystemsModelLabels -> None];ssmt = StateSpaceTransform[ssm, (| | |
| - | -- |
| 2 | -6 |
| 3 | -6 |)]Table[ObservableModelQ[sys], {sys, {ssm, ssmt}}]The controllable or controllable canonical realization is controllable:
ssm = StateSpaceModel[TransferFunctionModel[{{{1 + s}}, 2 + 3*s + s^2},
s], StateSpaceRealization -> "Controllable"]ControllableModelQ[ssm]But it is not necessarily observable:
ObservableModelQ[ssm]The observable or observable canonical realization is observable:
ssm = StateSpaceModel[TransferFunctionModel[{{{1 + s}}, 2 + 3*s + s^2},
s], StateSpaceRealization -> "Observable"]ObservableModelQ[ssm]But it is not necessarily controllable:
ControllableModelQ[ssm]The controllable companion and observable companion realizations are duals of each other:
{ssc, sso} = Table[StateSpaceModel[IconizedObject[«tfm»], StateSpaceRealization -> r], {r, {"ControllableCompanion", "ObservableCompanion"}}]The dual of the controllable companion is the observable companion:
{Refine[DualSystemsModel[ssc], {Subscript[b, _], Subscript[a, _]}∈Reals], sso}{Refine[DualSystemsModel[sso], {Subscript[b, _], Subscript[a, _]}∈Reals], ssc}A state-space model's state matrix satisfies its own characteristic polynomial:
StateSpaceModel[{𝒶 = (| | |
| --- | --- |
| a11 | a12 |
| a21 | a22 |), (| |
| --- |
| b11 |
| b21 |), (Subscript[c, 11] Subscript[c, 12])}]The characteristic polynomial:
charPoly = CharacteristicPolynomial[𝒶, s]It satisfies its characteristic polynomial as per the Cayley–Hamilton theorem:
Total[Map[#[[2]]MatrixPower[𝒶, #[[1, 1]]]&, CoefficientRules[charPoly, s]]]//SimplifyThe characteristic polynomial of the state matrix is the denominator of a transfer function model:
ssm = StateSpaceModel[{𝒶 = (| | |
| --- | --- |
| a11 | a12 |
| a21 | a22 |), (| |
| --- |
| b11 |
| b21 |), (Subscript[c, 11] Subscript[c, 12])}]CharacteristicPolynomial[𝒶, s] == Denominator[TransferFunctionModel[ssm][s][[1, 1]]]The eigenvalues of the state matrix determine the speed of the system's response:
{a, b, c} = {(| | |
| -- | -- |
| 0 | 2 |
| -1 | -3 |), (| |
| -- |
| 2 |
| -1 |), (2 3)};ssm = StateSpaceModel[{a, b, c}]or = Expand[OutputResponse[{ssm, {1, 1}}, 0, t]]The system response is determined by the exponents:
Cases[or, Power[E, Times[ev_, t]] :> ev, {0, ∞}]They are the eigenvalues of the state matrix:
% == Eigenvalues[a]Thus if the state matrix's eigenvalues are negative, the response decays exponentially to zero:
ssm = StateSpaceModel[{a, b, c} = {(| | |
| -- | -- |
| -6 | 0 |
| 3 | -3 |), (| |
| - |
| 1 |
| 0 |), (2 1)}]or = Expand[OutputResponse[{ssm, {1, 1}}, 0, t]]Limit[or, t -> ∞]This is because the eigenvalues are all negative:
AllTrue[Eigenvalues[a], Negative]If the eigenvalues are complex and on the left-hand plane, the response is oscillatory and decays to 0:
ssm = StateSpaceModel[{a, b, c} = {(| | |
| -- | --- |
| -3 | -20 |
| 1 | 1 |), (| |
| - |
| 1 |
| 0 |), (1 0)}]Its output response contains sinusoids:
or = OutputResponse[{ssm, {0.5, -0.5}}, 0, t]//SimplifyLimit[or, t -> ∞]This is because its eigenvalues are a complex pair in the left-hand plane:
Eigenvalues[a]The closer the eigenvalue pair is to the negative real axis, the more damped the oscillations:
{ssm1 = StateSpaceModel[{a1 = (| | |
| ---- | -- |
| 0 | 1 |
| -101 | -2 |), {{0}, {1}}, {{101, 0}}}], ssm2 = StateSpaceModel[{a2 = (| | |
| --- | -- |
| 0 | 1 |
| -26 | -2 |), {{0}, {1}}, {{26, 0}}}]}The second model's eigenvalues are closer to the negative real axis than the first's:
PoleZeroPlot[Table[ssm, {ssm, {ssm1, ssm2}}]]The second model's response is more damped:
Table[OutputResponse[ssm, UnitStep[t], {t, 0, 8}], {ssm, {ssm1, ssm2}}];
Plot[%, {t, 0, 8}, PlotRange -> All, PlotLegends -> {"ssm1", "ssm2"}]The further the complex eigenvalue pair is from the origin, the faster the response:
{ssm1 = StateSpaceModel[{a1 = (| | |
| --- | -- |
| 0 | 1 |
| -26 | -2 |), {{0}, {1}}, {{26, 0}}}], ssm2 = StateSpaceModel[{a2 = (| | |
| ---- | --- |
| 0 | 1 |
| -136 | -12 |), {{0}, {1}}, {{136, 0}}}]}The second model's eigenvalues are further away from the origin:
PoleZeroPlot[Table[ssm, {ssm, {ssm1, ssm2}}]]The second model's response is faster:
Table[OutputResponse[ssm, UnitStep[t], {t, 0, 7}], {ssm, {ssm1, ssm2}}];
Plot[%, {t, 0, 7}, PlotRange -> All, PlotLegends -> {"ssm1", "ssm2"}]The response of the first model to a unit-step input:
If an eigenvalue pair is on the imaginary axis and the rest are negative, the response has undamped oscillations:
ssm = StateSpaceModel[{a = (| | | |
| -- | -- | -- |
| 0 | 1 | 0 |
| 0 | 0 | 1 |
| -2 | -1 | -2 |), (| |
| - |
| 0 |
| 0 |
| 1 |), (1 0 0)}]Its output response has undamped sinusoidal expressions:
or = OutputResponse[{ssm, {1, 1}}, 0, t]//ExpandPlot[or, {t, 0, 15}, PlotRange -> All]This is because its eigenvalues include a negative value and a pair on the imaginary axis:
GatherBy[Eigenvalues[a], Re]If one of the eigenvalues is zero and the rest are negative, the response will have a nonzero offset:
ssm = StateSpaceModel[{a = (| | | |
| - | ---- | ---- |
| 0 | 1 | 0 |
| 0 | 0 | 1 |
| 0 | -1.5 | -3.5 |), (| |
| - |
| 0 |
| 0 |
| 1 |), (1 1 0)}]or = Expand[OutputResponse[{ssm, {1, 1}}, 0, t]]It converges on a nonzero value:
Limit[or, t -> ∞]This is because one of its eigenvalues is zero:
GatherBy[Eigenvalues[a], PossibleZeroQ]If multiple eigenvalues are zero, the response is unstable and diverges to ∞:
ssm = StateSpaceModel[{a = (| | | |
| - | - | -- |
| 0 | 1 | 0 |
| 0 | 0 | 1 |
| 0 | 0 | -4 |), (| |
| - |
| 0 |
| 0 |
| 1 |), (1 0 0)}]or = Expand[OutputResponse[{ssm, {1, 1}}, 0, t]]Limit[or, t -> ∞]This is because its eigenvalues include more than one zero:
Count[Eigenvalues[a], _ ? PossibleZeroQ]If an eigenvalue is positive, the response is unstable and diverges to ∞:
ssm = StateSpaceModel[{a = (| | | |
| - | --- | ---- |
| 0 | 1 | 0 |
| 0 | 0 | 1 |
| 9 | 4.5 | -2.5 |), (| |
| - |
| 0 |
| 0 |
| 1 |), (1 0 0)}]or = Expand[OutputResponse[{ssm, {1, 1}}, 0, t]]Limit[or, t -> ∞]This is because there is a positive eigenvalue:
Count[Eigenvalues[a], _ ? Positive]If a discrete-time model's eigenvalues are within the unit circle, its response decays to zero:
ssm = StateSpaceModel[{a = (| | |
| --- | ---- |
| 0 | 1 |
| 0.1 | -0.3 |), (| |
| - |
| 0 |
| 1 |), (1 0)}, SamplingPeriod -> 0.1]Its output response decays to zero:
OutputResponse[{ssm, {-1, 1}}, Table[0, 20]];
ListStepPlot[%, DataRange -> {0, 19 0.1}, PlotRange -> All]This is because its eigenvalues are within the unit circle:
AllTrue[Eigenvalues[a], Abs[#] < 1&]If any eigenvalue is outside the unit circle, the response is unstable:
ssm = StateSpaceModel[{a = (| | |
| - | -- |
| 0 | 1 |
| 6 | -1 |), (| |
| - |
| 0 |
| 1 |), (1 0)}, SamplingPeriod -> 0.1]Its response is unstable and diverges to ∞:
OutputResponse[{ssm, {-1, 1}}, Table[0, 20]];
ListStepPlot[%, DataRange -> {0, 19 0.1}, PlotRange -> All]This is because not all its eigenvalues are inside the unit circle:
AllTrue[Eigenvalues[a], Abs[#] < 1&]Possible Issues (4)
Nonlinearities in a model are approximated:
eqns = {Subscript[x, 1]'[t] == -Subscript[x, 2][t] + Subscript[u, 1][t], Subscript[x, 2]'[t] == -Subscript[x, 1][t]^2 + Subscript[u, 1][t] + Subscript[u, 2][t]};ssm = StateSpaceModel[eqns, {Subscript[x, 1][t], Subscript[x, 2][t]}, {Subscript[u, 1][t], Subscript[u, 2][t]}, Subscript[x, 1][t], t]Use a nonlinear model to prevent the approximation:
nssm = NonlinearStateSpaceModel[eqns, {Subscript[x, 1][t], Subscript[x, 2][t]}, {Subscript[u, 1][t], Subscript[u, 2][t]}, Subscript[x, 1][t], t]Compare the linear and nonlinear step responses:
Table[Plot[Evaluate[OutputResponse[sys[[1]], UnitStep[t], {t, 0, 15}]], {t, 0, 15}, IconizedObject[«plotOpts»]], {sys, {{ssm, "linear"}, {nssm, "nonlinear"}}}]The state matrix and input matrix must have the same number of rows:
StateSpaceModel[{(| | | |
| - | - | - |
| 0 | 1 | 0 |
| 2 | 1 | 0 |
| 4 | 0 | 0 |), (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |
| 0 | 2 |)}]Otherwise, the state-space model cannot be constructed:
StateSpaceModel[{(| | | |
| - | - | - |
| 0 | 1 | 0 |
| 2 | 1 | 0 |
| 4 | 0 | 0 |), (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |)}]The state matrix and output matrix must have the same number of columns:
StateSpaceModel[{(| | | |
| - | - | - |
| 0 | 1 | 0 |
| 2 | 1 | 0 |
| 4 | 0 | 0 |), (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |
| 0 | 2 |), (| | | |
| - | - | - |
| 1 | 0 | 0 |
| 1 | 0 | 2 |)}]Otherwise, the state-space model cannot be constructed:
StateSpaceModel[{(| | | |
| - | - | - |
| 0 | 1 | 0 |
| 2 | 1 | 0 |
| 4 | 0 | 0 |), (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |
| 0 | 2 |), (| | |
| - | - |
| 1 | 0 |
| 0 | 1 |)}]The transmission matrix must have the same number of rows as the output matrix and the same number of columns as the input matrix:
StateSpaceModel[{(| | | |
| - | - | - |
| 0 | 1 | 0 |
| 2 | 1 | 0 |
| 4 | 0 | 0 |), (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |
| 0 | 2 |), (| | | |
| - | - | - |
| 1 | 0 | 0 |
| 1 | 0 | 2 |), (| | |
| - | - |
| 0 | 0 |
| 0 | 0 |)}]Otherwise, the state-space model cannot be constructed
StateSpaceModel[{(| | | |
| - | - | - |
| 0 | 1 | 0 |
| 2 | 1 | 0 |
| 4 | 0 | 0 |), (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |
| 0 | 2 |), (| | | |
| - | - | - |
| 1 | 0 | 0 |
| 1 | 0 | 2 |), (0 0)}]Text
Wolfram Research (2010), StateSpaceModel, Wolfram Language function, https://reference.wolfram.com/language/ref/StateSpaceModel.html (updated 2014).
CMS
Wolfram Language. 2010. "StateSpaceModel." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2014. https://reference.wolfram.com/language/ref/StateSpaceModel.html.
APA
Wolfram Language. (2010). StateSpaceModel. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/StateSpaceModel.html