Systems#

Each type of dynamical system has a dedicated collection of routines to pose the Analysis and Synthesis problems.

The routines are

The opt_system algorithmic interconnection,
The regulator to build an internal model,
lmi_analysis and lmi_synthesis objects to pose the required LMIs.

The supported types of dynamical systems are

All component routines inherit from the generic interface.

System (Algorithmic Interconnection)#

class system.generic.opt_system_interface#

OPT_SYSTEM interconnection of network and operators by default is LTI (linear time invariant)

Constructor Summary

opt_system_interface(op, P, K, bind, tracking)#: OPT_SYSTEM constructor for the system :param P: network :type P: genplant :param K: controller :type K: genplant :param bind: indices for repeated oracle evaluations :type bind: int array :param tracking: exosystem to track the optimal solution :type tracking: struct

Property Summary

K#: controller

P#: network

bind#: which operators go to which output ports, for repeated evaluations

discount#: is the subsystem exponentially discounted?

op#: a cell of operators (op_sim for simulation, op_[] for analysis/synthesis)

tracking#: tracking of optimal solution (struct (S, R) by default)

type#

(e.g. lti, periodic, switched, mjls, lpv)

Type:: type of system

Method Summary

Nss()#: NSS: number of subsystems

build_plant_single(alg, iqc_data)#

BUILD_PLANT_SINGLE build a single plant (in a switched system) based on filtering the exponentially-discounted plant by an IQC

Parameters:

alg – original algorithm or network
iqc_data – IQCs for the oracle uncertainties

Return:

alg_psi – filtered algorithm
iqc_op – IQCS for the oracle uncertainties (altogether)
alg_loop – the discounted algorithm before applying the dynamical filter (for debugging)

discount_schedule(ordermax)#

DISCOUNT_SCHEDULE exponential weights encountered when applying the FIR filters

Parameters:

ordermax – maximum order of the IQCs

Return:

pow – Exponent sequence of discounts

Example:: [0; 1 ; 2] -> rho.^[0; 1; 2] for uniform exponential stability

export_sim(op_sim)#

export the system for use in simulation with the operators (for iqcs) replaced by operators (in op_sim)

Parameters:: op_sim – operators for simulation
Return:: sys_sim – system for use in alg_sim

get_alg(param)#

close the loop of the algorithm

Parameters:: param – structure of parameters
Return:: sys_alg – the dynamical system interfacing the operators

get_consensus(op, bind)#

GET_CONSENSUS create the consensus matrix for the regulation condition

Parameters:

op – cell of operator
bind – repeated patterns

Returns:

N – consensus matrix

get_consensus_weighted(op, bind)#

GET_CONSENSUS_WEIGHTED create the consensus matrix weight by the number of times the operator appears in bind

Parameters:

op – cell of operator
bind – repeated patterns

Returns:

N – consensus matrix

get_discount()#: should only certain modes be discounted

get_internal_signals(param, x_all, w_all)#

extract the internal signals from the interconnection (y, u) using the well-posedness expression

Parameters:

param – structure of parameters
x_all – all states of network and controller
w_all – all inputs to the network (except u)

Return:

y – input to controller/output of plant
u – output of controller/intput to plant

get_op(index)#: get the operator at index :param index: the index

get_tracked_opt(param)#

GET_TRACKED_OPT get the tracked position of the optimal solution

\(\eta^*_{k+1} = S_\beta \eta^*, \beta^*_{k} = R_\beta \eta_k\).

Args:
param: structure of parameters

Returns:

Sbeta – exosystem for optimal solution
Rbeta – output of optimal solution

get_type()#: type of dynamical system (e.g. LTI, switched)

n()#: n: number of states

next_mode(mode)#: next mode in switching

nu()#: nu: number of states in network

ny()#: nu: number of states in network

ss_zy_wu(param)#: get state space matrices at the current parameter values

Regulator#

Both Analysis and Synthesis require a confirmation of the Regulator Equation.

class system.generic.regulator_interface#

REGULATOR_INTERFACE

A regulator employed for the synthesis of optimization algorithms

This regulator carries the necessary internal model required for convergence of optimization algorithms (constant shift of optimal solution), as well as extra states associated with position of the unknown disturbance. This regulator is adjoined to the network dynamics in synthesis of algorithms.

The regulator allows for the perfect tracking of optimal solutions (if known) by the tracking dynamics (Sbeta, Rbeta) in (sys).

The regulator is specialized for a specific kind of system

Constructor Summary

regulator_interface(sys)#: REGULATOR_INTERFACE Constructor for a regulator

Property Summary

Gam#: regulator equation solution, tracking input of controller

Gam_basis#: nullspace, freedom to choose Gamma

Phi#: regulator equation solution, tracking output of controller

Phi_basis#: nullspace, freedom to choose Phi

Pi#: regulator equation solution, tracking state of network

Pi_basis#: nullspace, freedom to choose Pi

R#: tracking of optimal solution and subgradients (output)

S#: tracking of optimal solution and subgradients (propagation)

sys#: the system

Method Summary

check_regulator()#

check the regulator equation for a specific system

Return:: reg_cl (reg_cl_out) – closed-loop regulator structure if succesful, empty if infeasible.

compute_Phi(Pi, Gam, param)#

get the tracked controller input from the regulator equation solution

Parameters:

Pi – tracked state of network
Gam – tracked controller output
param – other parameters (if needed)

Return:

Phi – tracked controller input

create_vars(param_null)#

CREATE_VARS: create variables that parameterize the nullspace

Parameters:

param_null (bool) – should the nullspace be searched (as
variables)

Returns:

vars_reg – structure with fields (Pi, Gam, Phi)

d_influence(param)#

D_INFLUENCE how does the system get affected by the disturbance? used for the internal model computation

Returns:

Bd – disturbance to state
Ded – disturbance to regulated error
Dyd – disturbance to controller input

exosystem(param)#: get the exosystem at each mode/internal model

extract_opt_from_d(param)#: extract the quantities to follow (w, z) from the disturbance

fetch_model(S, Phi, Gam)#

FETCH_MODEL fetch an internal model from the current regulator equation solution

Parameters:

S – exosystem generator
Phi – tracked controller input
Gam – tracked controller output

Return:

model – the full-order internal model

form_internal_model()#: FORM_INTERNAL_MODEL create the internal model by solving the regulator equation. Inputs are the system (P, bind, tracking, op) op is important for which oracles are equaltiy constraints and which are inequality constraints

Warning

If regulator equation is unsolvable, then no optimization algorithm can be found.

get_K(param)#: get the controller

get_consensus()#: get the consensus matrix

get_tracked_opt(param)#: get the part of the exosystem corresponding to tracking the optimal solution at each mode/internal model

ns()#: NS number of states of exosystem

null_reg_all(reg_mat)#

NULL_REG nullspace of the regulator equations: freedom to move

Parameters:

reg_mat – solution to linear system for the regulator
equation

Returns:

Pi_basis – nullspace, freedom to choose Pi
Gam_basis – nullspace, freedom to choose Gamma
Phi_basis – nullspace, freedom to choose Phi

reg_K_sys_all()#

assemble the closed-loop regulator equation system

Returns:

reg_mat – matrix for regulator equation
reg_ans – vector for regulator equation solution

reg_K_sys_indiv(param)#: control regulator equation checks (closed-loop)

reg_K_sys_next(param)#: control closed-loop regulator equation checks next expression

reg_sys_all()#: constraints for the current system, assembling regulator equations

reg_sys_indiv(param)#

constraints for the current mode system, assembling regulator equations

Returns:

reg_mat_dyn_L – matrix for regulator equation (left)
reg_mat_dyn_R – matrix for regulator equation (right)
reg_ans – vector for regulator equation solution

reg_sys_next(param)#: constraints for the next system, assembling regulator equations

sol_K_reg_all(reg_sol)#: recover the solution to the regulator equation system

sol_K_reg_index(reg_sol, param)#: index the solution to the regulator equation

sol_reg_all(reg_sol)#

recover the solution to the regulator equation system

Parameters:

reg_sol – solution of regulator equations

Return:

Pi – tracked state of network
Phi – tracked controller input
Gam – tracked controller output

sol_reg_index(reg_sol, param)#

index the solution to the regulator equation :param reg_sol: solution of regulator equations :param param: other parameters

Return:

Pi – tracked state of network
Phi – tracked controller input
Gam – tracked controller output

ss_zy_wu(param)#: get plant matrices for the system

sys_regulated_aug()#: the enriched system with the disturbance channel

For Analysis, the output of the check_regulator() function is contained in a separate class. If check_regulator() fails, then the algorithmic interconnection is not guaranteed to converge.

class system.generic.reg_cl_out#

REG_CL_OUT Output structure for closed-loop regulator equation

Constructor Summary

reg_cl_out()#: REG_CL_OUT Constructor

Property Summary

Gam#: regulator equation solution, tracking input of controller

Phi#: regulator equation solution, tracking output of controller

Pi#: regulator equation solution, tracking state of network

R#: exosystem output to plant

S#: exosystem signal generator

Th#: regulator equation solution, tracking state of controller

W#: output of oracles at optimality

Z#: input of oracles at optimality

LMI Handler#

These routines are shared by both Analysis and Synthesis.

class system.generic.lmi_dispatch_interface#

Bases: handle

LMI_DISPATCH_INTERFACE analysis and synthesis LMIs for the algorithmic interconnections This contains generic routines common among both analysis and synthesis for every system type

Constructor Summary

lmi_dispatch_interface(sys, config)#: LMI_DISPATCH_INTERFACE Construct the analysis or synthesis program :param sys: algorithmic system :param config: configuration options

Property Summary

config#: configuration options

reduced#: reduced-order control

reg#: the regulator for the system

sys#: the algorithmic system

Method Summary

LMILAB()#: is LMILAB used?

con_dynamic_single(vars, cons, diss)#

CON form a single dissipation and sign constraint

Parameters:

vars – variables of the problem
diss (diss_data) – information about dissipation relation % param: other parameters

Returns:

cons – accumulated constraints
objective – term to be minimized
con_M – PSD blocks for the dynamics constraint

con_spread(cons, vars)#

CON_SPREAD increase numerical conditioning by separating the primal and dual blocks. :param cons: accumulated constraints :param vars: variables of the problem

Returns:: cons – accumulated constraints

cons_dynamic(vars, cons, diss)#

CONS form the dissipation and sign constraints

Parameters:

vars – variables of the problem
cons – accumulated constraints
diss (diss_data) – structure describing the dissipation constraint %

Returns:

cons – accumulated constraints
objective – term to be minimized

e2e(vars, cons, diss)#

E2E, energy to energy gain :param vars: variables of the problem :param cons: accumulated constraints :param diss: structure describing the dissipation constraint :type diss: diss_data

Returns:

cons – accumulated constraints
objective – term to be minimized
con_M – PSD blocks for the dynamics constraint

ergodic(vars, cons, diss)#

ERGODIC certification of ergodic convergence. call quadratic performance. :param vars: variables of the problem :param cons: accumulated constraints :param diss: structure describing the dissipation constraint :type diss: diss_data

Returns:

cons – accumulated constraints
objective – term to be minimized
con_M – PSD blocks for the dynamics constraint

h2_block(plant, G, vars_spec, Omega)#

h2_BLOCK supply block used in stochastic h2 analysis programs :param plant: plant to analyze :param G: storage function :param vars_spec: variable for h2 constraint :param Omega: covariance of noise

Returns:: con_Z – output constraint to build h2 relation

l2_stability(vars, cons, diss)#

l2_stability, bounded l2 gain (input to state stability) :param vars: variables of the problem :param cons: accumulated constraints :param diss: structure describing the dissipation constraint :type diss: diss_data

Returns:

cons – accumulated constraints
objective – term to be minimized
con_M – PSD blocks for the dynamics constraint

merge_quad(M_rob, M_spec)#

merge together quadratic performance specifications; :param M_rob: quadratic constraint for operator uncertainty :param M_spec: quadratic constraint for performance

Return:: quad_m – quadratic performance structure

merge_spec_M(iqc_rob, sp, vars_spec)#

MERGE_SPEC_M merge the running cost of the robustness and the performance specification

Parameters:

iqc_rob – robust IQC
sp – performance specification
vars_spec – variables in the specification

Output:: M: merged quadratic performance specification

passivity(vars, cons, diss)#

PASSIVITY strict passivity specification :param vars: variables of the problem :param cons: accumulated constraints :param diss: structure describing the dissipation constraint :type diss: diss_data

Returns:

cons – accumulated constraints
objective – term to be minimized
con_M – PSD blocks for the dynamics constraint

perf_block(plant, quad)#

PERF_BLOCK performance block used in analysis programs :param plant: plant to analyze :param quad: running cost

Returns:: pb – performance term to build dissipation relation

quad_objective(M_quad, ind_p, ind_q)#

QUAD_OBJECTIVE untangle the quadratic objective into a linearizable formulation :param M_quad: quadratic performance matrix :param ind_p: indices for output of filtered system :param ind_q: indices for input of filtered system

Output:: quad: quadratic performance structure

separate_performance_output(diss)#

SEPARATE_PERFORMANCE_OUTPUT extract the performance output from the plant, used in reduced-order control

Parameters:: diss – information about dissipation relation

Notes

marked for deletion

This routine is used in the computation of l2 norms via Schur complements

stability(vars, cons, diss)#

STABILITY certification of exponential stability the supply function in the specification is empty, so just call quadratic performance.

Parameters:

vars – variables of the problem
cons – accumulated constraints
diss (diss_data) – structure describing the dissipation constraint

Returns:

cons – accumulated constraints
objective – term to be minimized
con_M – PSD blocks for the dynamics constraint

supply_block(plant, M)#

SUPPLY_BLOCK supply block used in analysis programs :param plant: plant to analyze :param M: running cost

Returns:: sb – supply term to build dissipation relation

sys_block(plant, Gnew, Gold, rho)#

SYS_BLOCK system block used in analysis programs :param plant: plant to analyze :param Gnew: new storage function :param Gold: old storage function :param rho: discount rate

Returns:: sb – dynamics term to build dissipation relation

validate_recovery_gain(alg_psi, iqc_op_all, rho)#

VALIDATE_RECOVERY validate that the system obeys the stability constraint

Parameters:

alg_psi – the plant with confirmed performance by LMIs
iqc_op_all – all IQCs

Return:

gain – [Passivity index, H-infinity index].

LMI Analysis#

class system.generic.lmi_analysis_interface#

Bases: system.generic.lmi_dispatch_interface

LMI_ANALYSIS_INTERFACE Linear Matrix Inequality constraints for analysis of algorithmic interconnections.

this is overridden by specialized analysis routines for system types.

Constructor Summary

lmi_analysis_interface(sys, config)#

LMI_ANALYSIS_INTERFACE Constructor

Parameters:

sys – algorithmic system
config – configuration options

Warning

Error: Regulator equation of system must be solvable,: otherwise the algorithm is nonconvergent.

Property Summary

regcl#: closed-loop regulator equation

Method Summary

con_terminal(G, cons, iqc_op)#

CON_TERMINAL terminal cost constraint (nonnegativity for the storage function G) coupled positivity if the IQC has a terminal cost

Parameters:

G – storage matrix
cons – accumulated constraints
iqc_op – IQCs for the operators

Returns:

cons – accumulated constraints
con_X – terminal constraint expression

create_vars(vars, cons, alg_psi, specs)#

CREATE_VARS create the variables for the problem :param vars: problem variables :param cons: accumulated constraints :param alg_psi: generalized plant in analysis :param specs: specifications

Returns:

vars – problem variables
cons – accumulated constraints

create_vars_spec(cons, specs)#

CREATE_VARS_SPEC declare variables for the specifications

Parameters:

cons – accumulated constraints
specs – cell of specification

Returns:

vars – variables
cons – accumulated constraints

default_objective(vars)#

create an objective for mincx() if one doesn’t already: exist.

Parameters:: vars – variables of the problem
Returns:: objective – the objective to minimize

define_storage_G(cons, alg_psi, name)#

DEFINE_STORAGE_G storage function for a specific subsystem :param cons: accumulated constraints :param alg_psi: generalized plant in analysis :param name: name of the subsystem/object

Returns:

G – storage function
cons – accumulated constraints

partition_perf(diss)#

PARTITION_PERF partition the robust and performance channels

Parameters:

diss (diss_data) – current dissipation constraint

Returns:

plant_rob (sdpss) – plant with robust outputs
plant_perf (sdpss) – plant with performance outputs

partition_perf_zp(diss)#

PARTITION_PERF_zp partition the robust and performance channels ignore the performance inputs wp

Parameters:

diss (diss_data) – current dissipation constraint

Returns:

plant_rob (sdpss) – plant with robust outputs
plant_perf (sdpss) – plant with performance outputs

process_recovery(sol, lmi_out, alg_psi, diss)#

recover the controller :param sol: solution structure :param lmi_out: output from solver :param alg_psi: the filtered algorithmic interconnection :param diss: structure describing the dissipation constraint :type diss: diss_data

Returns:: sol – solution structure

quad_performance_augment(diss, vars, con_M, plant_perf)#

apply a quadratic performance constraint by Schur-Complement in Analysis

Parameters:

diss (diss_data) – current dissipation constraint
vars – variables of the problem
con_M (lmim) – current PSD constraint (LMI)
plant_perf (sdpss) – plant with performance outputs

Returns:

con_M_out (lmim) – Schur-complemented LMI constraint with robustness and performance
objective – the objective in optimization (scalar)

LMI Synthesis#

class system.generic.lmi_synthesis_interface#

Bases: system.generic.lmi_dispatch_interface

LMI_SYNTHESIS_INTERFACE Linear Matrix Inequality constraints for analysis of algorithmic interconnections.

Constructor Summary

lmi_synthesis_interface(sys, config)#: LMI_SYNTHESIS_INTERFACE Constructor for synthesis

Method Summary

K_alg_report(P_trans, K_nofeed, model, rho)#

K_ALG_REPORT recover the algorithmic interconnection and the controller :param P_trans: the transformed generalized plant before IQC :param K_nofeed: subcontroller without direct feedthrough :param model: internal model :param rho: discount rate

Return:: K_report – controller output structure

augment_vars(vars, diss, con_M)#: AUGMENT_VARS add new variables/terms for recovery (useful for matrix elimination). Overriden by LTI.

con_spread(cons, vars)#

CON_SPREAD increase numerical conditioning by separating the primal and dual blocks. invoke this over multiple subsystems

Parameters:

cons – accumulated constraints
vars – variables of the problem

Returns:

cons – accumulated constraints

con_spread_single(cons, GX, GY)#

CON_SPREAD_SINGLE increase numerical conditioning by separating the primal and dual blocks :param cons: accumulated constraints :param GX: primal storage matrix :param GY: dualstorage matrix

Returns:: cons – accumulated constraints

con_terminal(G, cons, alg_psi, iqc_op)#

CON_TERMINAL terminal cost constraint (nonnegativity for the storage function G) coupled positivity if the IQC has a terminal cost

Parameters:

G – closed-loop storage matrix
cons – accumulated constraints
alg_psi – the filtered algorithmic interconnection
specs – performance specifications
iqc_op – information about operator iqcs

Returns:

cons – accumulated constraints
con_X – the terminal PSD contraint

connect_model(diss, rho)#

connect the plant to the internal model :param diss: information about dissipation relation :type diss: diss_data :param rho: discount rate

Returns:: P_model – generalized plant with internal model attached

cons_dynamic(vars, cons, diss)#

CONS_DYNAMIC form the dissipation and sign constraints

Parameters:

vars – variables of the problem
cons – accumulated constraints
diss (diss_data) – structure describing the dissipation constraint

Returns:

cons – accumulated constraints
objective – term to be minimized

create_vars(vars, cons, alg_psi, specs)#

CREATE_VARS create the variables for the problem :param vars: variables of the problem :param cons: accumulated constraints :param diss: structure describing the dissipation constraint :type diss: diss_data :param alg_psi: the filtered algorithmic interconnection :param specs: performance specifications

Returns:

vars – variables of the problem
cons – accumulated constraints

create_vars_controller(cons, alg_psi, name, D_mask)#

CREATE_VARS_CONTROLLER create the nonlinearly-transformed controller matrices, used for convexification :param cons: accumulated constraints :param alg_psi: the filtered algorithmic interconnection :param name: a name for the variable :param D_mask: sparsity pattern for D of the controller

Returns:

vars_K – controller variables [Ak, Bk, Ck, Dk], or some subset if elimination is used.
cons – accumulated constraints

create_vars_regulator()#: CREATE_VARS_REGULATOR parameterize the solutions to the regulator equations use this as a variable in reduced-order control :Returns: vars_reg – variables of the problem (regulator)

create_vars_spec(cons, specs)#

CREATE_VARS_SPEC declare variables for the specifications :param cons: accumulated constraints :param specs: performance specifications

Returns:: vars_spec – variables for performance specification cons: accumulated constraints

create_vars_storage(cons, alg_psi, name)#

create_vars_storage create variables for the dissipation constraints

Parameters:

cons – accumulated constraints
alg_psi – the filtered algorithmic interconnection
name – a name for the variable

Returns:

vars_diss – variables of the problem in the dissipation constraints
cons – accumulated constraints

default_objective(vars)#

create an objective for mincx() if one doesn’t already: exist.

Parameters:: vars – variables of the problem
Returns:: objective – the objective to minimize

define_storage_G(cons, alg_psi, name)#

DEFINE_STORAGE_G storage function for a specific subsystem :param cons: accumulated constraints :param alg_psi: the filtered algorithmic interconnection :param specs: performance specifications :param name: a name for the variable

Returns:

GX – primal storage matrix
GY – dual storage matrix
cons – accumulated constraints

dynamics_block(sys_cl, quad, herm)#

DYNAMICS_BLOCK form the supply block in a quadratic objective problem

Parameters:

sys_cl – closed-loop system dynamics
quad – quadratic performance criteria (used for dimensions)
herm (bool) – symmetrize the term? true by default

Returns:

dyn_b_he – dynamics term to build dissipation relation
U_outer – left outer product in elimination
V_outer – right outer product in elimination

dynamics_block_null(sys_cl, quad, herm)#

DYNAMICS_BLOCK_NULL form the supply block in a p2p quadratic objective: problem

Parameters:

sys_cl – closed-loop system dynamics
quad – quadratic performance criteria (used for
dimensions)
herm (bool) – symmetrize the term? true by default

Returns:

dyn_b_he – dynamics term to build dissipation relation
U_outer – left outer product in elimination
V_outer – right outer product in elimination

e2e_target(vars, cons, diss)#

E2E_target: energy to energy gain is a special case of quadratic performance :param vars: variables of the problem :param cons: accumulated constraints :param diss: structure describing the dissipation constraint :type diss: diss_data

Returns:

cons – accumulated constraints
objective – term to be minimized
con_M – PSD blocks for the dynamics constraint

elimination()#: is matrix elimnation allowed?

form_Dk(alg_psi, D_mask, name, include_Dk1)#

FORM_Dk: lower triangular structure needed for the controller need a better interface for the mask :param alg_psi: the filtered algorithmic interconnection :param D_mask: sparsity pattern for D of the controller :param name: a name for the variable :param include_Dk1: should the feed into the internal model :type include_Dk1: bool :param be included? true by default: :param false for reduced-order: :param control.:

Return:: Dk – controller matrix

get_D_mask()#

GET_D_MASK get the sparsity pattern for the direct feedthrough controller term

Returns:: D_mask – sparsity pattern for D of the controller

get_GY_dim(n, ns)#: dimension of the GY term

get_K_mask(nxi)#

K_mask: get the controller sparsity pattern

Parameters:: nxi – number of controller states
Return:: K_mask – pattern of the controller

get_K_tri_basis(nxi)#

GET_K_TRI_BASIS get a basis for the triangular elimination method.

Parameters:

nxi – number of controller parameters

Returns:

U (cell) – left factor in outer products
V (cell) – right factor in outer products

get_storage(vars_diss, vars_reg)#

GET_STORAGE get the storage function matrix G :param vars_diss: variables of the problem in the dissipation constraints :param vars_reg: variables for regulator equation

Returns:: G – the closed-loop storage matrix (warped)

h2_block(plant, G, vars_spec, Omega)#

h2_BLOCK supply block used in stochastic h2 analysis programs :param plant: plant to analyze :param G: storage function :param vars_spec: variable for h2 constraint :param Omega: covariance of noise

Returns:: con_Z – output constraint to build h2 relation

name_K_feed(K_in)#

NAME_K_FEED assign names to the channels of the subcontroller

Parameters:: K_in – controller original
Return:: K_feed – named controller

partition_perf_zp(diss)#

PARTITION_PERF_zp partition the robust and performance channels ignore the performance inputs wp

Parameters:

diss (diss_data) – current dissipation constraint

Returns:

plant_rob (sdpss) – plant with robust outputs
plant_perf (sdpss) – plant with performance outputs

process_recovery(sol, lmi_out, alg_psi, diss)#

Returns:: sol – solution structure

recover_K_from_elim(vars_rec)#

recover the Ak and Ck matrices overridden by matrix elimination :param vars_rec: recovered variables from solver

Returns:: Ak, Bk, Ck, Dk – controller matrices

recover_subcontroller(alg_psi, P_trans, sol)#

RECOVER_SUBCONTROLLER recover the subcontroller of the entire program.

Parameters:

alg_psi – the filtered algorithmic interconnection
P_trans – the transformed generalized plant before IQC
sol – solution structure

Returns:

sol – solution structure

recover_subcontroller_warp(P_trans, vars_rec)#

RECOVER_SUBCONTROLLER_WARP recover the nonlinearly warped controller :param alg_psi: the filtered algorithmic interconnection :param P_trans: the transformed generalized plant before IQC :param sol: solution structure

Output:: K_nofeed: subcontroller without direct feedthrough Gcl: closed-loop storage matrix (original) Ycl: similarity transformation/nonlinear warping

reduced_order()#: is this a reduced-order controller? Default to no

storage_block(sys_cl, quad, G_curr, G_next)#

STORAGE_BLOCK form the storage block in a synthesis problem :param sys_cl: closed-loop system dynamics :param quad: quadratic performance criteria (used for :param dimensions): :param G_curr: current time step closed-loop storage matrix :param G_next: next time step closed-loop storage matrix

Returns:: stor_b – storage term to build dissipation relation

supply_block(sys_cl, quad)#

SUPPLY_BLOCK form the supply block in a quadratic objective problem :param sys_cl: closed-loop system dynamics :param quad: quadratic performance criteria (used for dimensions)

Returns:: supp_b – supply term to build dissipation relation

used_rho(diss)#: which rho to use? Common formulation (noncausal) vs. exponential formulation (causal, multiperformance)

Dissipation Container#

The dissipation constraints are stored in diss_data. This container is used to construct the LMIs in Analysis and Synthesis.

manager.diss_data#

Systems

Contents

Systems#

System (Algorithmic Interconnection)#

Regulator#

LMI Handler#

LMI Analysis#

LMI Synthesis#

Dissipation Container#