controller structure & nonsmooth programming - Pierre Apkarian - Free

controller structure 

& 

nonsmooth programming 

Institut für Systemtheorie und Regelungstechnik, January 

2012, Stuttgart 

Invitation Carsten Scherer 

Pierre Apkarian 

ONERA & UPS/Institut de Mathématiques, Toulouse, France

challenges nonsmooth opt. MATLAB tools The End 

outline 

1 challenges with control structures, multi-loop architectures 

2 nonsmooth optimization 

3 MATLAB tuning tools 

4 conclusion 

 

controller structure & nonsmooth programming - http://pierre.apkarian.free.fr 

2 / 28



• PID simple white-box structure 

K p 

Ki 

s 

Kds 

1+Ts 

• 3 tunable structured blocks 

• K i , K p , K d and T design variables with assigned roles 

• easily retuned, scheduled & implemented 

 


3 / 28


Riccati, LMI, full-order controllers 

z 

y 

P(s) 

w 

u 

K(s) 

• full-order controller has no structure [DGKF 1989] 

• centralized monolithic black box 

• no physical insight into what the controller does 

• often high order and unduly complex (freq. weight size inflation) 

• often require post-processing (reduction, equil., scaling, etc) 

 


4 / 28


why enforcing controller structure 

easier to understand role of components 

scheduling and implementation are simpler 

facilitates re-tuning (component-wise if necessary) 

mandatory in some applications (decentralized, etc) 

stems from theoretical characterizations (µ, anti wind-up, dyn. 

inversion) 

good control architectures pave the way to good designs 

 


5 / 28



• more complicated aircraft longitudinal law 

reference 

model 

R(s) 

z 1 

− 

feed 

forward 

F f (s) 

z 2 

r 

− 

K p + Ki 

s 

− 

roll−off 

filter 

F (s) 

aircraft 

G(s) 

N z 

q 

K q(s) 

w 

• tunable blocks often designed independently (suboptimal) 

 


6 / 28



• helicopter multi-loop MIMO architecture 

bank of PIDs 

bank of roll−off filters 

PID 

roll−off 

filter 

set−points 

_ 

PID 

_ 

roll−off 

filter 

Helicopter 

H 

θ 

φ 

r 

PID 

roll−off 

filter 

static gain 

• 7 blocks (42 tunable parameters) 

• tuning is complicate because of loop interactions 

 


7 / 28



• decentralized control has diagonal structure 

• mandatory in some applications 

z 

w 

. 

P(s) 

. 

yq 

Kq(s) 

uq 

yq−1 

Kq−1(s) 

uq−1 

. 

y1 

K1(s) 

u1 

• one-loop-at-a-time synthesis is time consuming and tedious 

 


8 / 28



• multiple model synthesis has replicated decentralized controller 

z 1 

P 1 11(s) 0 P 1 12(s) 0 

w 1 

z 2 0 P11(s) 2 0 P12(s) 

2 w 2 

y 1 u 1 

P21(s) 1 0 P22(s) 1 0 

y 2 

0 P 2 21(s) 0 P 2 22(s) 

u 2 

K(s) 0 

0 

K(s) 

• N copies if N systems 


 

9 / 28

˜Dω 

˜Dω 



• robust complex µ synthesis reformulated as structured controller 

design 

Dω 

P(s) 

Dω 

−1 

P(s) 

− 

P c(s) 

y 

u 

y 

u 

y 

u 

C(s) 

C(s) 

C(s) 

˜D(s) 

˜D(s) 

• abstract controller has repeated diagonal structure (2 copies of D-scale) 

• one shot without D-K-iteration and SISO fitting 

• can be extended to multiplier-based and IQC syntheses 


 

10 / 28



• anti wind-up involves two-block structured controller 

J(s) 

− 

y 

K(s) 

u 

sat 

ũ 

• design for 2 operating modes 

• numerous variants 


 

11 / 28


joint model and controller design 

• both p (feedback) and Π (model) are tunable 

model parameters 

Π 

z 

# 

P 

w 

z 

P 

w 

y 

u 

y 

C(s,p) 

u 

C(s,p) 

0 

0 

Π 

controller 

p & Π tunable 

• again is highly structured 


 

12 / 28


challenges with structured synthesis 

sequential design of components is time consuming 

biconvex schemes (D-K like) fail to converge 

global solutions are not systematically accessible (NP-hard 

non-convex) 

Riccati and LMI approaches do not help 

BMI formulations remain costly and unreliable 

• estimate local solutions using specialized nonsmooth 

programming 


 

13 / 28


viewpoint 

this work privileges local paradigm 

• local solutions to realistic problems 

versus 

• global solutions to conservative relaxations 

• on the bad side: practical problems are nonconvex and/or nonsmooth 


 

14 / 28


dimensionality: an illustrative example 

transport aircraft at flutter condition 

stabilization with static output feedback u = Ky : 

[ ] [ ] [ ] 

ẋ A B x 

= 

, A : 55 × 55, K : 2 × 2 

y C 0 u 


 

15 / 28





[ ] [ ] [ ] 

ẋ A B x 

= 

, A : 55 × 55, K : 2 × 2 

y C 0 u 

BMI: (A + BKC) T P + P(A + BKC) ≺ 0 et P = P T ≻ 0 

⇒ 1544 variables most of them (1540) for Lyapunov matrix P 

min α(A + BKC) where α max Re λ i is spectral abscissa 

K 

⇒ 4 variables : tunable controller parameters 

tunable space is small if accepting nonsmooth formulations 

i 


 

15 / 28





[ ] [ ] [ ] 

ẋ A B x 

= 

, A : 55 × 55, K : 2 × 2 

y C 0 u 

BMI: (A + BKC) T P + P(A + BKC) ≺ 0 et P = P T ≻ 0 

⇒ 1544 variables most of them (1540) for Lyapunov matrix P 

min α(A + BKC) where α max Re λ i is spectral abscissa 

K 

⇒ 4 variables : tunable controller parameters 

tunable space is small if accepting nonsmooth formulations 

⇒ recast controller design as nonsmooth program 

i 


 

15 / 28


controller design as nonsmooth (minimax) 

optimization 

stabilization 

min 

K 

max 

i 

Re λ i (A + BKC) 


 

16 / 28



optimization 

stabilization 

min 

K 

max 

i 


H ∞ synthesis (triply nonsmooth) 

min 

K 

max max 

ω∈[0,+∞] i 

σ i 

( 

Tw→z (K, jω) ) 16 / 28 

controller structure & nonsmooth programming - http://pierre.apkarian.free.fr



optimization 

stabilization 

min 

K 

max 

i 

H ∞ synthesis (triply nonsmooth) 

min 

K 

time-domain design 

max max 

ω∈[0,+∞] i 


σ i 

( 

Tw→z (K, jω) ) 

min 

K 

max max 

t∈[0,+∞] 

{ (z(K, 

t) − zmax (t) ) + 

, 

( 

zmin (t) − z(K, t) ) + } 16 / 28 

controller structure & nonsmooth programming - http://pierre.apkarian.free.fr


controller design as nonsmooth program 

• optimization problems are nonsmooth and/or nonconvex 

• but gentle special composite structure with cast 

minimize 

x 

max λ 1 ◦ T (x, ω) 

ω∈Ω 

Ω index set freq. or times 

where max Ω∈Ω λ 1 is convex but nonsmooth 

T (x, Ω) differentiable but nonconvex wrt. x, ∀ω 


 

17 / 28





minimize 

x 

max λ 1 ◦ T (x, ω) 

ω∈Ω 




• Clarke subdifferential 

Clarke calculus is closed (chain rules, etc) 

Clarke regularity ⇒ specialized and efficient techniques 


 

17 / 28





minimize 

x 

max λ 1 ◦ T (x, ω) 

ω∈Ω 




• Clarke subdifferential 

Clarke calculus is closed (chain rules, etc) 

Clarke regularity ⇒ specialized and efficient techniques 

• directly formulated in controller tunable space (no dummies !) 

• efficient: can handle large models 


 

17 / 28


nonsmooth notions 

• directional derivative df (x; d) = max < z, d > 

z∈∂f (x) 

• Clarke’s gradient qualifies directions. df (x; d) < 0 for descent 

• x ∗ local minimum then 0 ∈ ∂f (x ∗ ) 

• ∂f (x) is convex hull of active branches in f (x) := 

max f (x, ω) 

ω∈(0,∞) 

smooth functions 

∇f (x, ω2) 

nonsmooth functions 

∇f (x) ∇f (x, ω1) 

∂f (x) 

0 ∈ ∂f (x) 

descent cone 

half space 

descent cone 

∇f (x, ω3) 

∇f (x, ω1) 

∇f (x, ω2) 


 

18 / 28


building the tangent model (extension set) 

σ1[Tw→z (K, jω)] 

multiple active frequencies 

‖Tw→z (K, ·)‖∞ 

bracketting freq. 

candidate 

nearly active 

0 

log ω (rad.s −1 ) 

• active frequencies often conflicting 

• smooth algorithms fail because of waterbed effect 

• capture all active frequencies and secondary pics (anticipate) 

• computations based on Hamiltonian method 


 

19 / 28


nonsmooth technique pseudo-code 

scheme 

1 compute an extension set of the Clarke subdifferential of the H ∞ objective 

2 estimate local curvature to speed up convergence 

3 form tangent program and compute descent direction 

4 perform line search 

5 loop over 1-4 until convergence 

• stopping test and remote (global) convergence 

P. Apkarian, D. Noll, 2006. 


 

20 / 28


HINFSTRUCT from Matlab RCT 2010b and 

higher 

• nonsmooth codes are slow as a rule (1st-order gradient type) 

• HINFSTRUCT is specialized to H ∞ computations 

• turns out fast and reliable on most problems 

• can tune arbitrary control architectures 

• ideally suited to small tunable space for up to large size plants 

• implementation is touchy (people, years and routines) 


 

21 / 28


software for structured H ∞ synthesis 

z1 

z w 1 

w2 

2 

. 

P(s) . 

y 

u 

C 1(s,p) 

0 

. . . 

0 

C (s,p) 

C (s,p) 

N 

multidisk constraints 

T w 1 z(s,p) 1 


illustration: 

% PID controller (PRE-DEFINED BLOCK) 

C = ltiblock.pid(’C’,’pid’); 

% Low-pass filter (CUSTOM BLOCK) 

a = realp(’a’,1); 

F = tf(a,[1 a]); 

% Parametric model of sensitivity S 

S = feedback(1,G*C*F); 

( wS S 

∥ w T T 

)∥ ∥∥∥∥∞ 

< 1 

% Mixed-sensitivity tuning of C and a 

H0 = [wS * S ; wT * (1-S)]; % H0 initial object 

H = hinfstruct(H0); % H tuned object 


 

23 / 28


create tunable objects using MATLAB 

interface 

% create an observer-based controller 

K = realp(’K’,zeros(nu,nx)); % state feedback 

L = realp(’L’,eye(nx,ny)); 

% observer gain 

% observer-based controller in SS format 

OBC = ss(A-B*K-L*(C-D*K),L,-K,0) ; 

% generate synthesis interconnection 

T = lft( P , OBC ) ; % tunable object: K & L as tunable 


 

24 / 28


longitudinal passenger jet 

• requirements: setpoint tracking, roll-off, gain-phase margins 

• 5 tunable blocks 


 

25 / 28


workflow 1 

• specify tunable blocks in Simulink model 

ST = slTunable(’passenger_jet’,{’Ki’,’Kp’,’Kq’,’Kf’,’RollOff’}); 

• initialize roll-off filter 

wn = realp(’wn’, 3); zeta = realp(’zeta’,0.8); 

Fro = tf(wn^2,[1 2*zeta*wn wn^2]); 

ST.setBlockParam(’RollOff’,Fro) 

• define spec. channels 

T1=ST.getIOTransfer(’Nzc’,’e’); % tracking 

T2=ST.getIOTransfer(’n’,’delta_m’); % roll-off 

T3=ST.getIOTransfer(’w’,’delta_m’); % margins 

• add weighting filters for each spec. 

H0 = blkdiag( W1*T1, W2*T2, W3*T3) 

Magnitude (dB) 

80 

60 

40 

20 

0 

−20 

−40 

−60 

W1 (tracking) 

W2 (roll−off) 

W3 (margins) 

Bode Diagram 

no cross terms here! 

−80 

−100 

−120 

10 −3 10 −2 10 −1 10 0 10 1 10 2 10 3 10 4 10 5 

Frequency (rad/s) 


 

26 / 28


workflow 2 

• tune parameters with HINFSTRUCT 

H = hinfstruct(H0); % H is tuned version of H0 

• push tuned values into structure for simulation 

ST.setBlockValue(H) ; 

Step Response 

Step Response 

1.4 

1.2 

From: Nzc To: Nz 

Actual response 

Gref response 

0.01 

0.005 

From: Nzc To: delta m 

Total 

Feedforward 

Feedback 

80 

60 

Bode Diagram 

From: delta m 

To: delta m 

Open−Loop Response 

1/W2 

N z 

1 

0.8 

0.6 

δ m 

0 

−0.005 

−0.01 

−0.015 

−0.02 

Magnitude (dB) 

40 

20 

0 

−20 

−40 

180 

90 

0.4 

0.2 

−0.025 

−0.03 

−0.035 

Phase (deg) 

0 

−90 

−180 

0 

0 1 2 3 4 5 6 

Time (sec) 

−0.04 

0 1 2 3 4 5 6 

Time (sec) 

−270 

10 −3 10 −2 10 −1 10 0 10 1 

Frequency (rad/s) 

• single run < 4 sec. on desktop PC 


 

27 / 28


conclusion 

• HINFSTRUCT and LOOPTUNE can tune with simple workflow 

any multi-loop control architecture made of finely structured 

components 

any closed-loop object possibly model parameters 

multiple models (nominal and faulty) 

• LOOPTUNE reduces guesswork (tweaks weights for you) 

• fast and efficient solvers endowed with local certificate 

• good benchmarking techniques to test your owns 


28 / 28

controller structure & nonsmooth programming - Pierre Apkarian - Free

Create successful ePaper yourself

Delete template?

Save as template?