cbadc.analog_system.analog_system.AnalogSystem

class cbadc.analog_system.analog_system.AnalogSystem(A: ndarray, B: ndarray, CT: ndarray, Gamma: Optional[ndarray] = None, Gamma_tildeT: Optional[ndarray] = None, D: Optional[ndarray] = None, B_tilde: Optional[ndarray] = None, A_tilde: Optional[ndarray] = None)

Bases: object

Represents an analog system.

The AnalogSystem class represents an analog system goverened by the differential equations,

\(\dot{\mathbf{x}}(t) = \mathbf{A} \mathbf{x}(t) + \mathbf{B} \mathbf{u}(t) + \mathbf{\Gamma} \mathbf{s}(t)\)

where we refer to \(\mathbf{A} \in \mathbb{R}^{N \times N}\) as the system matrix, \(\mathbf{B} \in \mathbb{R}^{N \times L}\) as the input matrix, and \(\mathbf{\Gamma} \in \mathbb{R}^{N \times M}\) is the control input matrix. Furthermore, \(\mathbf{x}(t)\in\mathbb{R}^{N}\) is the state vector of the system, \(\mathbf{u}(t)\in\mathbb{R}^{L}\) is the vector valued, continuous-time, analog input signal, and \(\mathbf{s}(t)\in\mathbb{R}^{M}\) is the vector valued control signal.

The analog system also has two (possibly vector valued) outputs namely:

• The control observation \(\tilde{\mathbf{s}}(t)=\tilde{\mathbf{\Gamma}}^\mathsf{T} \mathbf{x}(t) + \tilde{\mathbf{D}} \mathbf{u}(t)\) and

• The signal observation \(\mathbf{y}(t) = \mathbf{C}^\mathsf{T} \mathbf{x}(t) + \mathbf{D} \mathbf{u}(t)\)

where \(\tilde{\mathbf{\Gamma}}^\mathsf{T}\in\mathbb{R}^{\tilde{M} \times N}\) is the control observation matrix, \(\tilde{\mathbf{D}}\in\mathbb{R}^{\tilde{M} \times L}\) is the direct control observation matrix, and \(\mathbf{C}^\mathsf{T}\in\mathbb{R}^{\tilde{N} \times N}\) is the signal observation matrix.

Parameters

• A (array_like, shape=(N, N)) – system matrix.

• B (array_like, shape=(N, L)) – input matrix.

• CT (array_like, shape=(N_tilde, N)) – signal observation matrix.

• Gamma (array_like, shape=(N, M)) – control input matrix.

• Gamma_tildeT (array_like, shape=(M_tilde, N)) – control observation matrix.

• D (array_like, shape=(N_tilde, L), optional) – the direct matrix, defaults to None

• D_tilde (array_like, shape=(M_tilde, L), optional) – the direct control observation matrix, defaults to None

• A_tilde (array_like, shape=(M_tilde, N), optional) – the self control observation matrix, defaults to None

N

state space order \(N\).

Type

int

N_tilde

number of signal observations \(\tilde{N}\).

Type

int

M

number of digital control signals \(M\).

Type

int

M_tilde

number of control signal observations \(\tilde{M}\).

Type

int

L

number of input signals \(L\).

Type

int

A

system matrix \(\mathbf{A}\).

Type

array_like, shape=(N, N)

B

input matrix \(\mathbf{B}\).

Type

array_like, shape=(N, L)

CT

signal observation matrix \(\mathbf{C}^\mathsf{T}\).

Type

array_like, shape=(N_tilde, N)

Gamma

control input matrix \(\mathbf{\Gamma}\).

Type

array_like, shape=(N, M)

Gamma_tildeT

control observation matrix \(\tilde{\mathbf{\Gamma}}^\mathsf{T}\).

Type

array_like, shape=(M_tilde, N)

t

the symbolic time variable.

Type

sympy.Symbol

x

a list containing the state variable functions.

Type

[sympy.Function]

See also

cbadc.simulator.StateSpaceSimulator

Example

>>> import numpy as np
>>> from cbadc.analog_system import AnalogSystem
>>> A = np.array([[1, 2], [3, 4]])
>>> B = np.array([[1], [2]])
>>> CT = np.array([[1, 2], [0, 1]]).transpose()
>>> Gamma = np.array([[-1, 0], [0, -5]])
>>> Gamma_tildeT = CT.transpose()
>>> system = AnalogSystem(A, B, CT, Gamma, Gamma_tildeT)

Raises

InvalidAnalogSystemError – For faulty analog system parametrization.

Methods

__init__(A, B, CT[, Gamma, Gamma_tildeT, D, ...])	Create an analog system.
control_observation(t, x[, u, s])	Computes the control observation for a given state vector \(\mathbf{x}(t)\) evaluated at time \(t\).
control_signal_transfer_function_matrix(omega)	Evaluates the transfer functions between control signals and the system output.
derivative(x, t, u, s)	Compute the derivative of the analog system.
eta2(BW)	Compute the eta2 parameter of the system.
homogenius_solution()	Compute the symbolic homogenious solution
signal_observation(x)	Computes the signal observation for a given state vector \(\mathbf{x}(t)\) evaluated at time \(t\).
symbolic_differential_equations(input, dim)	Organise system matrixes into ordinary differential equations
transfer_function_matrix(omega[, symbolic, ...])	Evaluate the analog signal transfer function at the angular frequencies of the omega array.
zpk([input])	return zero-pole-gain representation of system

Attributes

pre_computable
A
B
CT
Gamma
Gamma_tildeT
D
D_tilde
A_tilde
N
N_tilde
M
M_tilde
L

control_observation(t: float, x: ndarray, u: ndarray = None, s: ndarray = None) → ndarray

Computes the control observation for a given state vector \(\mathbf{x}(t)\) evaluated at time \(t\).

Specifically, returns

\(\tilde{\mathbf{s}}(t) = \tilde{\mathbf{\Gamma}}^\mathsf{T} \mathbf{x}(t) + \tilde{\mathbf{D}} \mathbf{u}(t)\)

Parameters

• x (array_like, shape=(N,)) – the state vector.

• u (array_like, shape=(L,)) – the input vector

• s (array_like, shape=(M,)) – the control signal

Returns

the control observation.

Return type

array_like, shape=(M_tilde,)

control_signal_transfer_function_matrix(omega: ndarray) → ndarray

Evaluates the transfer functions between control signals and the system output.

Specifically, evaluates

\(\bar{\mathbf{G}}(\omega) = \mathbf{C}^\mathsf{T} \left(\mathbf{A} - i \omega \mathbf{I}_N\right)^{-1} \mathbf{\Gamma} \in \mathbb{R}^{\tilde{N} \times M}\)

for each angular frequency in omega where \(\mathbf{I}_N\) represents a square identity matrix of the same dimensions as \(\mathbf{A}\) and \(i=\sqrt{-1}\).

Parameters

omega (array_like, shape=(K,)) – an array_like object containing the angular frequencies for evaluation.

Returns

the signal transfer function evaluated at K different angular frequencies.

Return type

array_like, shape=(N_tilde, M, K)

derivative(x: ndarray, t: float, u: ndarray, s: ndarray) → ndarray

Compute the derivative of the analog system.

Specifically, produces the state derivative

\(\dot{\mathbf{x}}(t) = \mathbf{A} \mathbf{x}(t) + \mathbf{B} \mathbf{u}(t) + \mathbf{\Gamma} \mathbf{s}(t)\)

as a function of the state vector \(\mathbf{x}(t)\), the given time \(t\), the input signal value \(\mathbf{u}(t)\), and the control contribution value \(\mathbf{s}(t)\).

Parameters

• x (array_like, shape=(N,)) – the state vector evaluated at time t.

• t (float) – the time t.

• u (array_like, shape=(L,)) – the input signal vector evaluated at time t.

• s (array_like, shape=(M,)) – the control contribution evaluated at time t.

Returns

the derivative \(\dot{\mathbf{x}}(t)\).

Return type

array_like, shape=(N,)

eta2(BW)

Compute the eta2 parameter of the system.

Parameters

BW (float) – bandwidth of the system

Returns

eta2 parameter of the system at bandwidth BW

Return type

float

homogenius_solution()

Compute the symbolic homogenious solution

This is done by analytically computing the matrix exponential

\(\exp(\mathbf{A} t)\)

Returns

the resulting matrix expression.

Return type

sympy.Matrix

signal_observation(x: ndarray) → ndarray

Computes the signal observation for a given state vector \(\mathbf{x}(t)\) evaluated at time \(t\).

Specifically, returns

\(\mathbf{y}(t)=\mathbf{C}^\mathsf{T} \mathbf{x}(t)\)

Parameters

x (array_like, shape=(N,)) – the state vector.

Returns

the signal observation.

Return type

array_like, shape=(N_tilde,)

symbolic_differential_equations(input: Function, dim: int, input_signal=True)

Organise system matrixes into ordinary differential equations

Parameters

• input (sympy.Matrix) – the input function

• dim (int) – the dimension of the input

• input_signal (bool) – determine if it is a input signal or digital control that is to be computed, defaults to True (input signal not control).

Returns

• [:py:class:`sympy:Eq] – the resulting symbolic system equations

• [sympy:Function] – the functions for which the equations relate.

transfer_function_matrix(omega: ndarray, symbolic: bool = False, general=False) → ndarray

Evaluate the analog signal transfer function at the angular frequencies of the omega array.

Specifically, evaluates

\(\mathbf{G}(\omega) = \mathbf{C}^\mathsf{T} \left(\mathbf{A} - i \omega \mathbf{I}_N\right)^{-1} \mathbf{B} + \mathbf{D}\)

for each angular frequency in omega where \(\mathbf{I}_N\) represents a square identity matrix of the same dimensions as \(\mathbf{A}\) and \(i=\sqrt{-1}\).

Parameters

• omega (array_like, shape=(K,)) – an array_like object containing the angular frequencies for evaluation.

• symbolic (bool, optional) – solve using symbolic methods, defaults to True.

• general (bool, optional) – to return general transfer function or not, defaults to False.

Returns

the signal transfer function evaluated at K different angular frequencies.

Return type

array_like, shape=(N_tilde, L, K)

zpk(input=0)

return zero-pole-gain representation of system

Parameters

• input – determine for which input (in case of L > 1) to compute zpk, defaults to 0.

• int – determine for which input (in case of L > 1) to compute zpk, defaults to 0.

• optional – determine for which input (in case of L > 1) to compute zpk, defaults to 0.

Returns

z,p,k the zeros, poles and gain of the system

Return type

array_like, shape=(?, ?, 1)