Wolfram Language & System Documentation Center

ControllableDecomposition

yields the controllable subsystem of the state-space model sys.

ControllableDecomposition[sys,{z₁,…}]

specifies the new state variables z_i.

Details and Options

ControllableDecomposition gives {p,csys}, where p is the transformation and csys is the controllable subsystem.
The system sys can be a standard or descriptor StateSpaceModel or AffineStateSpaceModel.
The controllable subsystem is given by StateSpaceTransform[sys,p].
ControllableDecomposition accepts a Method option. The following settings can be specified:
Automatic automatically choose the method

"Matrix" use the controllability matrix

"Distribution" use the controllability distribution

Examples

open all close all

Basic Examples (1)

Find the controllable subsystem and its transformation:

Wolfram Language code:

ControllableDecomposition[StateSpaceModel[{{{Subscript[a, 1], 0, 0}, {0, Subscript[a, 2], 0}, 
   {0, 0, Subscript[a, 3]}}, {{0}, {Subscript[b, 1]}, 
   {Subscript[b, 2]}}, {{Subscript[c, 1], Subscript[c, 2], 
    Subscript[c, 3]}}, {{Subscript[d, 11]}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None]]

Scope (4)

The controllable subsystem of a controllable system is the complete system:

Wolfram Language code:

ControllableDecomposition[StateSpaceModel[{{{-1, -2}, {3, -4}}, {{1}, {-1}}, {{1, 0}}, {{0}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None]]

The controllable subsystem of a partially controllable continuous-time system:

Wolfram Language code:

ControllableDecomposition[StateSpaceModel[{{{-3, 0, 0}, {0, -4, 0}, {0, 0, -7}}, {{1}, {-1}, {0}}, {{1, 0, 0}}, {{0}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> None]]

The controllable subsystem of a descriptor system:

Wolfram Language code:

ControllableDecomposition[StateSpaceModel[{{{Subscript[a, 1], 0, 0}, {0, Subscript[a, 2], 0}, 
   {0, 0, Subscript[a, 3]}}, {{0, 0}, {Subscript[b, 1], 0}, 
   {0, Subscript[b, 2]}}, {{0, Subscript[c, 1], 0}, 
   {0, 0, Subscript[c, 3]}}, 
  {{Subscript[d, 11], Subscript[d, 12]}, 
   {Subscript[d, 21], Subscript[d, 22]}}, 
  {{Subscript[e, 1], 0, 0}, {0, Subscript[e, 2], 0}, {0, 0, 0}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> None]]

The controllable subsystem of an affine system:

Wolfram Language code:

asys = AffineStateSpaceModel[{{Subscript[x, 1], Subscript[x, 1], 
   Subscript[x, 1]}, {{1}, {1 + Subscript[x, 1]}, {1}}, 
  {Subscript[x, 1]}, {{0}}}, {Subscript[x, 1], 
  Subscript[x, 2], Subscript[x, 3]}, {{Subscript[, 1], 0}}, 
 {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: ControllableDecomposition[asys]

Specify the new state variables:

Wolfram Language code: ControllableDecomposition[asys, {Subscript[z, 1], Subscript[z, 2], Subscript[z, 3]}]

Applications (7)

Linear Systems (4)

Construct the Kalman controllable decomposition:

Wolfram Language code:

ssm = StateSpaceModel[{{{Subscript[a, 1], 0, 0}, {0, Subscript[a, 2], 0}, 
   {0, 0, Subscript[a, 3]}}, {{0, 0}, {Subscript[b, 1], 0}, 
   {0, Subscript[b, 2]}}, {{Subscript[c, 1], 0, 0}, 
   {0, 0, Subscript[c, 3]}}, 
  {{Subscript[d, 11], Subscript[d, 12]}, 
   {Subscript[d, 21], Subscript[d, 22]}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None];

ControllableDecomposition picks out the controllable subsystem only:

Wolfram Language code: {p, cssm} = ControllableDecomposition[ssm];

Wolfram Language code: cssm

Kalman controllable decomposition puts the controllable subsystem first and keeps the rest:

Wolfram Language code:

po = NullSpace[p];
StateSpaceTransform[ssm, ArrayFlatten[{{p, po}}]]

Compute the dimension of the controllable subspace:

Wolfram Language code:

{p, cssm} = ControllableDecomposition[StateSpaceModel[{{{Subscript[a, 1], 0, 0}, {0, Subscript[a, 2], 0}, 
   {0, 0, Subscript[a, 3]}}, {{0, 0}, {Subscript[b, 1], 0}, 
   {0, Subscript[b, 2]}}, {{Subscript[c, 1], 0, 0}, 
   {0, 0, Subscript[c, 3]}}, 
  {{Subscript[d, 11], Subscript[d, 12]}, 
   {Subscript[d, 21], Subscript[d, 22]}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None]];

The controllable subspace is the range of p, i.e. the column dimension:

Wolfram Language code: Dimensions[p]//Last

Find the controllable subspace for the system below and explain the possible state trajectories that can occur in the system:

Wolfram Language code:

ssm = StateSpaceModel[{{{1, -1, -3}, {-3, -1, 3}, {5, -1, -7}}, {{0}, {0}, {-1}}, {{1, -1, -1}}, {{0}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> None];

The system is uncontrollable, so only a subspace is controllable:

Wolfram Language code: ControllableModelQ[ssm]

The range of the transformation matrix p gives the controllable subspace:

Wolfram Language code: {p, csys} = ControllableDecomposition[ssm];

Wolfram Language code: cspace = ParametricPlot3D[p.{u, v}, {u, -1.25, 1.25}, {v, -1, 1}, Mesh -> None, PlotStyle -> Opacity[0.3]]

Trajectories can be controlled in this subspace:

Wolfram Language code:

x0 = Flatten[Table[p.{u, v}, {u, -0.8, 0.8, 0.3}, {v, -0.8, 0.8, 0.3}], 1];
sr = Table[StateResponse[{ssm, x}, Sin[2t], {t, 0, 10}], {x, x0}];

Wolfram Language code: Show[ParametricPlot3D[Evaluate[sr], {t, 0, 10}], cspace]

But you cannot control the drift between parallel copies of the controllable subspace:

Wolfram Language code:

w = First@NullSpace[p]; (* Orthogonal direction to cspace *)
x0 = Flatten[Table[p.{u, v} - w, {u, -0.8, 0.8, 0.3}, {v, -0.8, 0.8, 0.3}], 1];
sr = Table[StateResponse[{ssm, x}, Sin[2t], {t, 0, 10}], {x, x0}];

Wolfram Language code: Show[ParametricPlot3D[Evaluate[sr], {t, 0, 10}], cspace]

Design a controller for a system that is not completely controllable, by building a controller for the controllable subsystem:

Since a force applied only on the first mass , the second mass is not controllable:

Wolfram Language code: pars = {Subscript[k, 1] -> 75, Subscript[k, 2] -> 100, Subscript[m, 1] -> 1, Subscript[m, 2] -> 0.5};

Wolfram Language code:

ssm = StateSpaceModel[{{{0, 1, 0, 0, 0, 0}, 
   {-(Subscript[k, 1] + Subscript[k, 2])/Subscript[m, 1], 0, 
    Subscript[k, 2]/Subscript[m, 1], 0, 0, 0}, {0, 0, 0, 1, 0, 0}, 
   {Subscript[k, 2]/Subscript[m, 2], 0, 
    -Subscript[k, 2]/Subscript[m, 2], 0, 0, 0}, {0, 0, 0, 0, 0, 1}, 
   {0, 0, 0, 0, -Subscript[k, 2]/Subscript[m, 2], 0}}, 
  {{0}, {Subscript[m, 1]^(-1)}, {0}, {0}, {0}, {0}}, 
  {{1, 0, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0}}, {{0}, {0}}}, 
 {{Subscript[y, 2][t], 0}, Subscript[, 1], 
  {Subscript[x, 1][t], 0}, Subscript[, 2], 
  {Subscript[x, 2][t], 0}, Subscript[, 3]}, 
 {{F[t], 0}}, {Subscript[x, 1][t], 
  Subscript[x, 2][t]}, t, SamplingPeriod -> None, 
 SystemsModelLabels -> None] /. pars;

Wolfram Language code: ControllableModelQ[ssm]

Design a controller using the controllable subsystem:

Wolfram Language code: {p, csys} = ControllableDecomposition[ssm];

Wolfram Language code: κc = StateFeedbackGains[csys, {-1, -2, -3 + I, -3 - I}]

Use the transformation to obtain the controller for the original system:

Wolfram Language code: κ = κc.p

The simulation shows controlled as well as oscillatory modes in the closed-loop system:

Wolfram Language code: clsys = SystemsModelStateFeedbackConnect[ssm, κ];

Wolfram Language code: Plot[Evaluate[StateResponse[{clsys, {0, 0, 0.1, 0, 0.1, 0}}, 0, {t, 0, 7}]], {t, 0, 7}]

Compute the modes of the closed-loop system:

Wolfram Language code: Eigenvalues[First[Normal[clsys]]]

The oscillatory modes are the uncontrollable ones:

Wolfram Language code: Select[Eigenvalues[First[Normal[ssm]]], !ControllableModelQ[{ssm, #}]&]

Affine Systems (3)

Construct the triangular controllability decomposition:

Wolfram Language code:

assm = AffineStateSpaceModel[{{1, 0, Subscript[x, 2]}, {{1}, {Subscript[x, 2]}, 
   {Subscript[x, 1]}}, {Subscript[x, 1]}, {{0}}}, 
 {Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]}, 
 {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None];

ControllableDecomposition picks out the controllable subsystem only:

Wolfram Language code: {{p1, p2}, csys} = ControllableDecomposition[assm];

Wolfram Language code: csys

Triangular controllability decomposition puts the controllable subsystem first and keeps the rest:

Wolfram Language code: StateSpaceTransform[assm, {p1, Flatten[p2]}]

Compute the dimension of the controllable subspace:

Wolfram Language code:

assm = AffineStateSpaceModel[{{Subscript[x, 1], Subscript[x, 1], 
   Subscript[x, 1]}, {{1}, {1 + Subscript[x, 1]}, {1}}, 
  {Subscript[x, 1]}, {{0}}}, {Subscript[x, 1], 
  Subscript[x, 2], Subscript[x, 3]}, {{Subscript[, 1], 0}}, 
 {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: ControllableModelQ[assm]

The dimension can be obtained from the inverse transformation :

Wolfram Language code: {{Subscript[p, 1], Subscript[p, 2]}, cssm} = ControllableDecomposition[assm];

Wolfram Language code: cssm

Wolfram Language code: Length[First[Subscript[p, 2]]]

The controllable decomposition gives the reachable subspace and subsystem. This can be used to visualize the motion of the system from one subspace to another:

Wolfram Language code:

asys = AffineStateSpaceModel[{{1, 0, Subscript[x, 2]}, {{1}, {Subscript[x, 2]}, 
   {Subscript[x, 1]}}, {Subscript[x, 1]}, {{0}}}, 
 {Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]}, 
 {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None];

The generic reachable subspace:

Wolfram Language code: {{Subscript[p, 1], {Subscript[p, 21], Subscript[p, 22]}}, csys} = ControllableDecomposition[asys];

Wolfram Language code:

rspace[{x1_, x2_, x3_}] := Last /@ Subscript[p, 22] /. {Subscript[x, 1] -> x1, Subscript[x, 2] -> x2, Subscript[x, 3] -> x3}

Wolfram Language code: rspace[{Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]}]

A specific reachable subspace:

Wolfram Language code: c = 0.2;

Wolfram Language code:

rspace0 = ContourPlot3D[Evaluate[rspace[{Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]}] == c], {Subscript[x, 1], 1, 5}, {Subscript[x, 2], 0, 5.5}, {Subscript[x, 3], -7, 7}, Mesh -> None, ContourStyle -> Opacity[0.3]]

Select several initial points on this surface:

Wolfram Language code: Subscript[x, 10] = Range[1.5, 3, 0.05];

Wolfram Language code:

Flatten[Subscript[x, 2] /. Solve[Thread[Last /@ Subscript[p, 22] == c], Subscript[x, 2]] /. Subscript[x, 1] -> Subscript[x, 10]];

Wolfram Language code: Subscript[x, 0] = Thread[{Subscript[x, 10], %, RandomReal[{-1.5, 6.5}, Length@Subscript[x, 10]]}];

Wolfram Language code: Short[Subscript[x, 0], 2]

All these initial points end up at exactly the same final surface because that motion is not controllable:

Wolfram Language code: sr = Table[StateResponse[{asys, x}, 0, {t, 0, 1}], {x, Subscript[x, 0]}];

Wolfram Language code: Subscript[x, f] = rspace /@ sr /. t -> 1;

Wolfram Language code: Differences[%]//Chop

A 3D plot shows the motion from the initial surface to the final one:

Wolfram Language code:

rspace1 = ContourPlot3D[Evaluate[rspace[{Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]}] == Subscript[x, f][[1, 1]]], {Subscript[x, 1], 1, 5}, {Subscript[x, 2], 0.5, 5}, {Subscript[x, 3], -10, 10}, Mesh -> None, ContourStyle -> Opacity[0.3]];

Wolfram Language code: Show[rspace0, ParametricPlot3D[Evaluate[sr], {t, 0, 1}], rspace1, PlotRange -> All]

Properties & Relations (2)

The transformation matrix p selects the controllable subsystem using StateSpaceTransform:

Wolfram Language code:

ssm = StateSpaceModel[{{{Subscript[a, 1], 0, 0}, {0, Subscript[a, 2], 0}, 
   {0, 0, Subscript[a, 3]}}, {{0, 0}, {Subscript[b, 1], 0}, 
   {0, Subscript[b, 2]}}, {{Subscript[c, 1], 0, 0}, 
   {0, 0, Subscript[c, 3]}}, 
  {{Subscript[d, 11], Subscript[d, 12]}, 
   {Subscript[d, 21], Subscript[d, 22]}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None];

Wolfram Language code:

{p, csys} = ControllableDecomposition[ssm];
tsys = StateSpaceTransform[ssm, {p, p}];

Wolfram Language code: {csys, tsys}

For affine systems, the transformation rules select the controllable subsystem:

Wolfram Language code:

assm = AffineStateSpaceModel[{{-Subscript[x, 4], 0, -Subscript[x, 1], 
   Subscript[x, 2]}, {{1}, {0}, {1 + Subscript[x, 2]}, {0}}, 
  {Subscript[x, 1], Subscript[x, 2]}, {{0}, {0}}}, 
 {Subscript[x, 1], Subscript[x, 2], Subscript[x, 3], 
  Subscript[x, 4]}, {Subscript[, 1]}, {Automatic, Automatic}, Automatic, 
 SamplingPeriod -> None];

Wolfram Language code:

{p, csys} = ControllableDecomposition[assm];
tsys = StateSpaceTransform[assm, p];

Wolfram Language code: {csys, tsys}

Top

More Learning

Tech Support

Wolfram Solutions

Wolfram Solutions For Education

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

ControllableDecomposition

Details and Options

Examples

Basic Examples (1)

Scope (4)

Applications (7)

Linear Systems (4)

Affine Systems (3)

Properties & Relations (2)

Text

CMS

APA

BibTeX

BibLaTeX

	Automatic	automatically choose the method
	"Matrix"	use the controllability matrix
	"Distribution"	use the controllability distribution

ControllableDecomposition

Details and Options

Examples

Basic Examples (1)

Scope (4)

Applications (7)

Linear Systems (4)

Affine Systems (3)

Properties & Relations (2)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX