MIMOStateSpace

Defined in module: wield.control.MIMO.ss.MIMOStateSpace

class MIMOStateSpace(*args, inputs=None, outputs=None, inout=None, hermitian=True, time_symm=False, dt=None, fiducial_rtol=None, fiducial_atol=None, algorithm_choices=None, algorithm_ranking=None)

Bases: BareStateSpaceUser, MIMO

State space class to represent MIMO Transfer functions using dense matrix representations

This class allows both string-based and number based indexing

inputs and outputs can either be a list of names or a dictionary of names to indices.

inputs and outputs can contain overlapping indices

__init__(*args, inputs=None, outputs=None, inout=None, hermitian=True, time_symm=False, dt=None, fiducial_rtol=None, fiducial_atol=None, algorithm_choices=None, algorithm_ranking=None)

Form a MIMO LTI system from statespace matrices.

There are lots of ways to create LTI systems. From the arguments

Methods

L2_norm(**kwargs)
Linf_norm(**kwargs)
__init__(*args[, inputs, outputs, inout, ...])	Form a MIMO LTI system from statespace matrices.
balance(**kwargs)
balanceABC(**kwargs)
balance_and_truncate(**kwargs)
constraint([outputs, matrix])	Adds an output constraint to the system and returns the altered system
constraints([output_matrix])	Adds multiple output constraints to the system and returns the altered system
dissect(*, ilists, inames, olists, onames)	This implements the dissection interface to break the statespace into blocks.
dissectB(iname)
dissectC(oname)
dissectD(iname, oname)
feedback_connect(*[, connections, gain])	Feedback linkage for a single statespace.
fresponse(*[, f, w, s])
in2out([inputs])
inverse(inputs, outputs)	Creates the inverse between the set of inputs and outputs.
minreal([job, scale_io, scale, tol])
namespace(ns)	prepend a namespace to all inputs and outputs and return the new system
out2in([outputs])
permute_UT(**kwargs)
print_nonzero()
reduceE(**kwargs)
reduceE2(**kwargs)
rename(renames[, which])	Rename inputs and outputs of the statespace and return the new systems
rename_inputs(renames)
rename_outputs(renames)
schur_form(**kwargs)
secondaries([outputs])	Return a new system with additional inputs and outputs created from the names of the originals
series_connect(*[, input_connections, ...])	Like feedback but extends inputs and outputs through gain or gain systems in series
set_algorithm_choices(algorithm_choices)
siso(row, col)	convert a single output (row) and input (col) into a SISO representation
stochastic_balance_and_truncate(**kwargs)

Attributes

A
ABCD
ABCDE
ABCDe
AE
Ae
B
C
D
E
algorithm_choices
algorithm_ranking
as_controlLTI
dt
e
hermitian
input_dissections_byname
isEeye
output_dissections_byname
structure_flags
time_symm

property input_dissections_byname

property output_dissections_byname

secondaries(outputs=None)

Return a new system with additional inputs and outputs created from the names of the originals

Properly implementing should use a topological sort on inputs and outputs to check for cycles and ensure that the index dependency is resolvable

siso(row, col)

convert a single output (row) and input (col) into a SISO representation

dissect(*, ilists, inames, olists, onames)

This implements the dissection interface to break the statespace into blocks. This is useful for a number of advanced control synthesis and analysis routines that depend on categories of input and output blocks

dissectB(iname)

dissectC(oname)

dissectD(iname, oname)

namespace(ns)

prepend a namespace to all inputs and outputs and return the new system

rename(renames, which='both')

Rename inputs and outputs of the statespace and return the new systems

renames: dictionary mapping from:to name pairs or a function(from) -> to which: can be “inputs”, “outputs”, or “both” (the default).

rename_inputs(renames)

rename_outputs(renames)

fresponse(*, f=None, w=None, s=None, **kwargs)

in2out(inputs=None)

out2in(outputs=None)

inverse(inputs, outputs)

Creates the inverse between the set of inputs and outputs. the size of inputs and outputs must be the same.

constraint(outputs=None, matrix=None)

Adds an output constraint to the system and returns the altered system

outputs: this is a list of outputs which establishes an order matrix: this is a matrix for the list of outputs which adds the system constraint G:=matrix -> G @ C @ x = 0 by augmenting the A and E matrices

constraints(output_matrix=[])

Adds multiple output constraints to the system and returns the altered system

output_matrix is a list of output, matrix pairs. This function is equivalent to calling constraint many times with the list, but is faster to perform all at once

series_connect(*, input_connections=None, output_connections=None, gain=1)

Like feedback but extends inputs and outputs through gain or gain systems in series

the gain terms can be SISO systems, StateSpaceRaw, D, ABCD, or ABCDE blocks

feedback_connect(*, connections=None, gain=1)

Feedback linkage for a single statespace.

connections is a list of row, col pairs or row,col,gain tuples

gain is the connection gain to apply. It can be a scalar or a matrix

TODO: allow gain to be a SISO response, StateSpaceRaw, D, ABCD, or ABCDE blocks

property A

property ABCD

property ABCDE

property ABCDe

property AE

property Ae

property B

property C

property D

property E

L2_norm(**kwargs)

Linf_norm(**kwargs)

property algorithm_choices

property algorithm_ranking

property as_controlLTI

balance(**kwargs)

balanceABC(**kwargs)

balance_and_truncate(**kwargs)

property dt

property e

property hermitian

property isEeye

minreal(job='minimal', scale_io=True, scale=True, tol=None)

permute_UT(**kwargs)

print_nonzero()

reduceE(**kwargs)

reduceE2(**kwargs)

schur_form(**kwargs)

set_algorithm_choices(algorithm_choices)

stochastic_balance_and_truncate(**kwargs)

property structure_flags

property time_symm