Marking Signals of Interest for Control System Analysis and Design

Analysis Points

Whether you model your control system in MATLAB® or Simulink®, use analysis points to mark points of interest in the model. Analysis points allow you to access internal signals, perform open-loop analysis, or specify requirements for controller tuning. In the block diagram representation, an analysis point can be thought of as an access port to a signal flowing from one block to another. In Simulink, analysis points are attached to the outports of Simulink blocks. For example, the reference signal, r, and the control signal, u, are analysis points of the following simple feedback loop model, ex_scd_analysis_pts1:

Figure 1: Simple Feedback Loop

Analysis points serve three purposes:

  • Input: The software injects an additive input signal at an analysis point, for example, to model a disturbance at the plant input, u.

  • Output: The software measures the signal value at a point, for example, to study the impact of this disturbance on the plant output, y.

  • Loop Opening: The software interprets a break in the signal flow at a point, for example, to study the open-loop response at the plant input, u.

You can apply these purposes concurrently. For example, to compute the open-loop response from u to y, you can treat u as both a loop opening and an input. When you use an analysis point for more than one purpose, the software always applies the purposes in a specific sequence: output (measurement), then loop opening, then input, as shown in the following diagram.

Figure 2: Analysis Point as Input, Output, and Loop Opening

Analysis points enable you to extract open-loop and closed-loop responses from a control system model. For example, suppose T represents the closed-loop system in the model ex_scd_analysis_pts1, and u and y are marked as analysis points. T can be either a generalized state-space model or an slLinearizer or slTuner interface to a Simulink model. You can plot the closed-loop response to a step disturbance at the plant input with the following commands:

Tuy = getIOTransfer(T,'u','y');

Analysis points are also useful to specify design requirements when tuning control systems with the systune command. For example, you can create a requirement that attenuates disturbances at the plant input by a factor of 10 (20 dB) or more.

Req = TuningGoal.Rejection('u',10);

Specifying Analysis Points for MATLAB Models

Consider an LTI model of the block diagram in Figure 1.

G = tf(10,[1 3 10]);
C = pid(0.2,1.5);
T = feedback(G*C,1);

With this model, you can obtain the closed-loop response from r to y. However, you cannot analyze the open-loop response at the plant input or simulate the rejection of a step disturbance at the plant input. To enable such analysis, mark the signal u as an analysis point by inserting an AnalysisPoint block between the plant and controller.

AP = AnalysisPoint('u');
T = feedback(G*AP*C,1);

The plant input, u, is now available for analysis. For instance, you can plot the open-loop response at u.


Recall that the AnalysisPoint block includes an implied loop-opening switch that behaves as shown in Figure 2 for analysis purposes. By default, this switch is closed when computing closed-loop responses. For example, plot the closed-loop response to a step disturbance at the plant input.

T.OutputName = 'y';

In creating the model T, you manually created the analysis point block AP and explicitly included it in the feedback loop. When you combine models using the connect command, you can instruct the software to insert analysis points automatically at the locations you specify. For more information, see the connect reference page.

Specifying Analysis Points for Simulink Models

In Simulink, you can mark analysis points either explicitly in the block diagram, or programmatically using the addPoint command for slLinearizer or slTuner interfaces.

To mark an analysis point explicitly in the block diagram, right-click on the signal and use the Linear Analysis Points menu. Select one of the closed-loop analysis types, unless you also want to add a permanent opening at this location. The closed-loop analysis types are Input Perturbation, Output Measurement, Sensitivity, and Complementary Sensitivity. The selected type does not affect analysis functions, such as getIOTransfer, and tuning goals, such as TuningGoal.StepTracking.

Figure 3: Marking Analysis Points in a Simulink Model

To mark analysis points programmatically, use addPoint for the slLinearizer or slTuner interfaces. Specify the point of interest using the block path, port number, and bus element, if applicable. For example, consider the ex_scd_analysis_pts2 model, illustrated in the next two figures.

Figure 4: Simple Feedback Loop in Simulink

Figure 5: 2DOF Controller Subsystem

Mark the u and Feedfordward term signals as analysis points.

ST = slLinearizer('ex_scd_analysis_pts2');
addPoint(ST,'ex_scd_analysis_pts2/2DOF Controller',1)
addPoint(ST,'ex_scd_analysis_pts2/2DOF Controller/Kff',1)

For convenience, you can also designate points of interest as analysis points using one of the abbreviations shown in the following examples:

  • Signal name:

  • Block name and port number:

  • Block name and outport name:

    addPoint(ST,'ex_scd_analysis_pts2/2DOF Controller/Control')
  • End of the full block name when unambiguous:


Finally, you can specify analysis points using linearization I/O objects (see linio):

ios = [...

As when you use the Linear Analysis Points to mark analysis points, analysis functions such as getIOTransfer and tuning goals such as TuningGoal.StepTracking ignore the actual I/O type. However, an I/O type that implies a loop opening, for instance loopbreak or openinput, imposes a permanent loop opening at the point. This permanent opening remains in force throughout analysis and tuning.

When you specify response I/Os in a tool such as Linear Analysis Tool or Control System Tuner, the software creates analysis points as needed.

Referring to Analysis Points for Analysis and Tuning

Once you have marked analysis points, you can analyze the response at any of these points using functions such as getIOTransfer and getLoopTransfer. You can also create tuning goals that constrain the system response at these points. The tools to perform these operations operate in a similar manner for models created at the command line and models created in Simulink.

Use the getPoints function to get a list of all available analysis points.

getPoints(T) % Model created at the command line
getPoints(ST) % Model created in Simulink

For closed-loop models created at the command line, you can also use the model input and output names as inputs to functions such as getIOTransfer.


Similarly, you can use these names to compute open-loop responses or create tuning goals for systune.

L = getLoopTransfer(T,'u',-1);

R = TuningGoal.Margins('u',10,60);

Use the same method to refer to analysis points for models created in Simulink. In Simulink models, for convenience, that you can use any unambiguous abbreviation of the analysis point names returned by getPoints.

L = getLoopTransfer(ST,'u',-1);


s = tf('s');
R = TuningGoal.Gain('Noise','Feedforw',1/(s+1));

Finally, if some analysis points are vector-valued signals or multichannel locations, you can use indices to select particular entries or channels. For example, suppose u is a two-entry vector in the model of Figure 2. You can compute the open-loop response of the second channel and measure the impact of a disturbance on the first channel, as shown here.

% Build closed-loop model of MIMO feedback loop
G = ss([-1 0.2;0 -2],[1 0;0.3 1],eye(2),0);
C = pid(0.2,0.5);
AP = AnalysisPoint('u',2);
T = feedback(G*AP*C,eye(2));
T.OutputName = 'y';

L = getLoopTransfer(T,'u(2)',-1);


When you create tuning goals in Control System Tuner, the software creates analysis points as needed.

See Also

| | |

Was this topic helpful?