getrom

This example shows how to obtain a reduced-order model using the balanced truncation of normalized coprime factors method.

Load a 30-state plant model G.

load ncfModel.mat G
size(G)

State-space model with 2 outputs, 3 inputs, and 30 states.

Create a model order reduction task.

R = reducespec(G,"ncf");

To help you select a suitable target reduction order, examine the plot of Hankel singular values and approximation errors.

Create the plot.

view(R)

The function generates a Hankel singular value plot, which shows the relative energy contributions of each state in the coprime factorization of G, arranged in decreasing order by energy. The plot also shows the upper bound on the error between the original and reduced-order models that you obtain by truncating the states at that point. Examine this plot to choose the target order. For instance, for a maximum error of 0.01, you can reduce the model to 13th order.

Examine the singular values of G and of the difference between G and Gred.

Gred = getrom(R,MaxError=0.01);
sigma(G,G-Gred)
legend("G","G-Gred")

The difference is small across all frequencies, showing that the reduced-order model is a good approximation of the full-order model.

This example show how to reduce controller order while preserving stability and robustness. This example requires Robust Control Toolbox™ software.

When you use normalized coprime factorization (NCF) balanced truncation with getrom to reduce a plant G or controller K for which the closed-loop response feedback(G*K,eye(n)) is stable, the resulting closed-loop response is also stable as long as the approximation error of the reduced model does not exceed the robustness margin computed by ncfmargin. To see this benefit of NCF balanced truncation, load a plant G and design a controller for it. For this example, use ncfsyn (Robust Control Toolbox) to design the controller.

load ncfStability.mat G
size(G)

State-space model with 1 outputs, 1 inputs, and 3 states.

% shaping weights
s = tf('s');
W1 = 3.35*tf([1 20.89],[1 0]);
W2 = 1;
% controller
[K,~,~,Kinfo] = ncfsyn(G,W1,W2); 
size(K)

State-space model with 1 outputs, 1 inputs, and 5 states.

ncfsyn designs a controller by optimizing the ncfmargin robustness margin using a plant shaped by weighting functions W1 and W2 (see ncfsyn (Robust Control Toolbox)). To analyze margins with ncfmargin and reduce controller order, work with the shaped plant Gs and the controller Ks designed for it.

Gs = Kinfo.Gs;
Ks = Kinfo.Ks;

Use ncfmargin (Robust Control Toolbox) to find the robustness margin of the system with the full-order controller. ncfsyn assumes a positive feedback loop while ncfmargin assumes negative feedback, so reverse the sign of the controller for this computation.

emax = ncfmargin(Gs,-Ks)

emax = 0.1956

As long as the approximation error of the reduced-order controller does not exceed emax, stability of the closed-loop system is preserved.

Create a model order reduction task using reducespec.

R = reducespec(Ks,"ncf");
R = process(R);

To select the reduced order, visualize the errors associated with each target order.

view(R)

Suppose that you can tolerate up to a 50% reduction in this margin in exchange for the computational benefit of a lower order controller.

Obtain the reduced-order model such that the target error does not exceed emax/2.

Ksr = getrom(R,MaxError=emax/2);
size(Ksr)

State-space model with 1 outputs, 1 inputs, and 3 states.

The reduced-order controller yields a very similar stability margin to the original controller.

ncfmargin(Gs,-Ksr)

ans = 0.1949

Reducing the controller order further leads to additional reduction in the stability margin. Reducing too far can lead to loss of closed-loop stability. For instance, try reducing to first order.

Ksru = getrom(R,Order=1);
ncfmargin(Gs,-Ksru)

ans = 0

Thus, for further analysis or implementation, use the third-order controller. To do so, convert Ksr, the reduced controller for Gs, into Kr, the reduced controller for G.

Kr = W1*Ksr*W2;

To confirm that this controller is satisfactory, compare the closed-loop response to the response with the full-order controller. Again, reverse the sign of the controller to account for ncfsyn assuming positive feedback.

CL = feedback(-G*K,1);
CLr = feedback(-G*Kr,1);
step(CL,CLr)
legend

The large overshoot in this case is due to instability of the original plant G.