StateSpace

Linear state-space system with operating point support.

Implements a linear, time-invariant state-space system of the form:

$$\dot{x}=Ax+B(u-u_0)$$$$y=Cx+D(u-u_0)+y_0$$

where:

• A is the system matrix (nx × nx)

• B is the input matrix (nx × nu)

• C is the output matrix (ny × nx)

• D is the feedthrough matrix (ny × nu)

• x is the state vector (nx × 1)

• u is the input vector (nu × 1)

• y is the output vector (ny × 1)

• u0 is the input operating point

• y0 is the output operating point

The operating point feature allows the system to operate around a specific steady-state condition, which is useful for linearization around an equilibrium.

Usage

StateSpace(A=fill(0.0, nx, nx), B=fill(1.0, nx, nu), C=fill(1.0, ny, nx), D=fill(0.0, ny, nu), x0=fill(0.0, nx), u0=fill(0.0, nu), y0=fill(0.0, ny))

Parameters:

Name	Description	Units	Default value
nx	Dimension of state vector	–	2
nu	Number of inputs	–	1
ny	Number of outputs	–	1
A	System matrix (nx × nx)	–	fill(0, nx, nx)
B	Input matrix (nx × nu)	–	fill(1, nx, nu)
C	Output matrix (ny × nx)	–	fill(1, ny, nx)
D	Feedthrough matrix (ny × nu)	–	fill(0, ny, nu)
x0	Initial state vector	–	fill(0, nx)
u0	Input operating point	–	fill(0, nu)
y0	Output operating point	–	fill(0, ny)

Connectors

• u - This connector represents a real signal as an input to a component (RealInput)

• y - This connector represents a real signal as an output from a component (RealOutput)

Variables

Name	Description	Units
x	State vector	–
Δu		–
Δy		–

Behavior

$$\begin{array}{rl}\mathtt{\Delta }\mathtt{u}\left(t\right)& =broadcast(-,u\left(t\right),\mathtt{u}\mathtt{0})\\ \mathtt{\Delta }\mathtt{y}\left(t\right)& =broadcast(-,y\left(t\right),\mathtt{y}\mathtt{0})\\ \frac{\mathrm{d}x\left(t\right)}{\mathrm{d}t}& =broadcast(+,Ax\left(t\right),B\mathtt{\Delta }\mathtt{u}\left(t\right))\\ \mathtt{\Delta }\mathtt{y}\left(t\right)& =broadcast(+,Cx\left(t\right),D\mathtt{\Delta }\mathtt{u}\left(t\right))\end{array}$$

Source

# Linear state-space system with operating point support.
#
# Implements a linear, time-invariant state-space system of the form:
#
# ```math
# \dot{x} = Ax + B(u - u_0)
# ```
# ```math
# y = Cx + D(u - u_0) + y_0
# ```
#
# where:
# - `A` is the system matrix (nx × nx)
# - `B` is the input matrix (nx × nu)
# - `C` is the output matrix (ny × nx)
# - `D` is the feedthrough matrix (ny × nu)
# - `x` is the state vector (nx × 1)
# - `u` is the input vector (nu × 1)
# - `y` is the output vector (ny × 1)
# - `u0` is the input operating point
# - `y0` is the output operating point
#
# The operating point feature allows the system to operate around a specific
# steady-state condition, which is useful for linearization around an equilibrium.
component StateSpace
  # Input connectors
  u = [RealInput() for i in 1:nu] [{"Dyad": {"placement": {"icon": {"x1": -50, "y1": 450, "x2": 50, "y2": 550}}}}]
  # Output connectors
  y = [RealOutput() for i in 1:ny] [{"Dyad": {"placement": {"icon": {"x1": 950, "y1": 450, "x2": 1050, "y2": 550}}}}]
  # Dimension of state vector
  structural parameter nx::Integer = 2
  # Number of inputs
  structural parameter nu::Integer = 1
  # Number of outputs
  structural parameter ny::Integer = 1
  # System matrix (nx × nx)
  parameter A::Real[nx,nx] = fill(0.0, nx, nx)
  # Input matrix (nx × nu)
  parameter B::Real[nx,nu] = fill(1.0, nx, nu)
  # Output matrix (ny × nx)
  parameter C::Real[ny,nx] = fill(1.0, ny, nx)
  # Feedthrough matrix (ny × nu)
  parameter D::Real[ny,nu] = fill(0.0, ny, nu)
  # Initial state vector
  parameter x0::Real[nx] = fill(0.0, nx)
  # Input operating point
  parameter u0::Real[nu] = fill(0.0, nu)
  # Output operating point
  parameter y0::Real[ny] = fill(0.0, ny)
  # State vector
  variable x::Real[nx]
  variable Δu::Real[nu]
  variable Δy::Real[ny]
relations
  initial x = x0
  Δu = u-u0
  Δy = y-y0
  # State equation: dx/dt = A*x + B*(u - u0)
  der(x) = A*x+B*Δu
  # Output equation: y = C*x + D*(u - u0) + y0
  Δy = C*x+D*Δu
end

Flattened Source

# Linear state-space system with operating point support.
#
# Implements a linear, time-invariant state-space system of the form:
#
# ```math
# \dot{x} = Ax + B(u - u_0)
# ```
# ```math
# y = Cx + D(u - u_0) + y_0
# ```
#
# where:
# - `A` is the system matrix (nx × nx)
# - `B` is the input matrix (nx × nu)
# - `C` is the output matrix (ny × nx)
# - `D` is the feedthrough matrix (ny × nu)
# - `x` is the state vector (nx × 1)
# - `u` is the input vector (nu × 1)
# - `y` is the output vector (ny × 1)
# - `u0` is the input operating point
# - `y0` is the output operating point
#
# The operating point feature allows the system to operate around a specific
# steady-state condition, which is useful for linearization around an equilibrium.
component StateSpace
  # Input connectors
  u = [RealInput() for i in 1:nu] [{"Dyad": {"placement": {"icon": {"x1": -50, "y1": 450, "x2": 50, "y2": 550}}}}]
  # Output connectors
  y = [RealOutput() for i in 1:ny] [{"Dyad": {"placement": {"icon": {"x1": 950, "y1": 450, "x2": 1050, "y2": 550}}}}]
  # Dimension of state vector
  structural parameter nx::Integer = 2
  # Number of inputs
  structural parameter nu::Integer = 1
  # Number of outputs
  structural parameter ny::Integer = 1
  # System matrix (nx × nx)
  parameter A::Real[nx,nx] = fill(0.0, nx, nx)
  # Input matrix (nx × nu)
  parameter B::Real[nx,nu] = fill(1.0, nx, nu)
  # Output matrix (ny × nx)
  parameter C::Real[ny,nx] = fill(1.0, ny, nx)
  # Feedthrough matrix (ny × nu)
  parameter D::Real[ny,nu] = fill(0.0, ny, nu)
  # Initial state vector
  parameter x0::Real[nx] = fill(0.0, nx)
  # Input operating point
  parameter u0::Real[nu] = fill(0.0, nu)
  # Output operating point
  parameter y0::Real[ny] = fill(0.0, ny)
  # State vector
  variable x::Real[nx]
  variable Δu::Real[nu]
  variable Δy::Real[ny]
relations
  initial x = x0
  Δu = u-u0
  Δy = y-y0
  # State equation: dx/dt = A*x + B*(u - u0)
  der(x) = A*x+B*Δu
  # Output equation: y = C*x + D*(u - u0) + y0
  Δy = C*x+D*Δu
metadata {}
end

Test Cases

No test cases defined.

Related

• Examples

• Experiments

• Analyses