frest.findSources

Package: frest

Identify time-varying source blocks

Syntax

blocks = frest.findSources(model) blocks = frest.findSources(model,io)

Description

blocks = frest.findSources(model) finds all time-varying source blocks in the signal path of any linearization output point marked in the Simulink^® model model.

blocks = frest.findSources(model,io) finds all time-varying source blocks in the signal path of any linearization output point specified in the array of linear analysis points io.

Input Arguments

model

Character vector or string that contains the name of the Simulink model in which you are identifying time-varying source blocks for frequency response estimation.

io

Array of linearization I/O points.

The elements of io are linearization I/O objects that you create with getlinio or linio. frest.findSources uses only the output points to locate time-varying source blocks that can interfere with frequency response estimation. See Algorithms for more information.

Output Arguments

blocks

Block paths of time-varying source blocks in model that can interfere with frequency response estimation, returned as an array of Simulink.BlockPath objects. blocks includes time-varying source blocks inside subsystems and normal-mode referenced models.

If you provide io, blocks contains all time-varying source blocks contributing to the signal at the output points in io.

If you do not provide io, blocks contains all time-varying source blocks contributing to the signal at the output points marked in model.

Examples

Estimate the frequency response of a model having time-varying source blocks. This example shows the use of frest.findSources to identify time-varying source blocks that interfere with frequency response estimation. You can also see the use of BlocksToHoldConstant option of frestimateOptions to disable time-varying source blocks in the estimation.

Load the model scdspeed_ctrlloop.

mdl = 'scdspeed_ctrlloop';
open_system(mdl)
% Convert referenced model to normal mode for accuracy 
set_param('scdspeed_ctrlloop/Engine Model',...
                    'SimulationMode','Normal');

First, view the effects of time-varying source blocks on frequency response estimation. To do so, perform the estimation without disabling time-varying source blocks.

In this example, linearization I/O points are already defined in the model. Use the getlinio command to get the I/O points for frestimate.

io = getlinio(mdl)

Define a sinestream signal and compute the estimated frequency response sysest.

in = frest.Sinestream('Frequency',logspace(1,2,10),...
              'NumPeriods',30,'SettlingPeriods',25);
[sysest,simout] = frestimate(mdl,io,in);

Perform exact linearization, and compare to the estimated response.

sys = linearize(mdl,io);
bodemag(sys,sysest,'r*')

The estimated frequency response does not match the exact linearization. The mismatch occurs because time-varying source blocks in the model prevent the response from reaching steady state.

Find the time-varying blocks using frest.findSources.

srcblks = frest.findSources(mdl);

srcblks is an array of block paths corresponding to the time-varying source blocks in the model. To examine the result, index into the array.

For example, entering

srcblks(2)

returns the result

ans = 

  Simulink.BlockPath
  Package: Simulink

  Block Path:
    'scdspeed_ctrlloop/Engine Model'
      'scdspeed_plantref/Drag Torque/Step1'

Now you can estimate the frequency response without the contribution of the time-varying source blocks. To do so, set the BlocksToHoldConstant option of frestimateOptions equal to srcblks, and run the estimation.

opts = frestimateOptions
opts.BlocksToHoldConstant = srcblks
% Run frestimate again with blocks disabled
 [sysest2,simout2] = frestimate(mdl,io,in,opts);

The frequency response estimate now provides a good match to the exact linearization result.

bodemag(sys,sysest2,'r*')

Tips

Use frest.findSources to identify time-varying source blocks that can interfere with frequency response estimation. To disable such blocks to estimate frequency response, set the BlocksToHoldConstant option of frestimateOptions equal to blocks or a subset of blocks. Then, estimate the frequency response using frestimate.
Sometimes, model includes referenced models containing source blocks in the signal path of a linearization output point. In such cases, set the referenced models to normal simulation mode to ensure that frest.findSources locates them. Use the set_param command to set SimulationMode of any referenced models to Normal before running frest.FindSources.

Algorithms

To locate time-varying source blocks that can interfere with frequency response estimation, frest.findSources begins at each linearization output point in the model. From each output point, the algorithm traces every signal path backward block by block. The algorithm reports any source block (a block with no input port) it discovers, unless that source block is a Constant or Ground block.

The frest.findSources algorithm traces every signal path that can affect the signal value at each linearization output point in the model. The paths traced include:

Signal paths inside virtual and nonvirtual subsystems.
Signal paths inside normal-mode referenced models. Set all referenced models to normal simulation mode before using frest.findSources to ensure that the algorithm identifies source blocks within the referenced models.
Signals routed through From and Goto blocks, or through Data Store Read and Data Store Write blocks.
Signals routed through switches. The frest.findSources algorithm assumes that any pole of a switch can be active during frequency response estimation. The algorithm therefore follows the signal back through all switch inputs.

Note

Some time-varying source blocks might not be found by frest.findSources. If the internal signal path of a block does not contain a block with no input port, that block is not reported by the function.

For example, consider the model scdspeed_ctrlloop. This model has one linearization output point, located at the output of the Sum block labeled Speed Output. (The frest.findSources algorithm ignores linearization input points.) Before running frest.findSources, convert the referenced model to normal simulation mode:

set_param('scdspeed_ctrlloop/Engine Model',...
                       'SimulationMode','Normal');

You can now run frest.findSources to identify the time-varying source blocks using the linearization output point defined in the model.

 srcblks = frest.findSources('scdspeed_ctrlloop');

The algorithm begins at the output point and traces back through the Sum block Speed Output. One input to Speed Output is the subsystem External Disturbance. The algorithm enters the subsystem, finds the source block labeled Step Disturbance, and reports that block.

The Sum block Speed Output has another input, which the algorithm traces back into the referenced model Engine Model. Engine Model contains several subsystems, and the algorithm traces the signal through these subsystems to identify any time-varying source blocks present.

For example, the Combustion subsystem includes the From block marked delta that routes the signal from the Spark Advance source. Because Spark Advance is a constant source block, however, the algorithm does not report the presence of the block.

The algorithm continues the trace until all possible signal paths contributing to the signal at each linearization output point are examined.

Alternatives

You can use the Simulink Model Advisor to determine whether time-varying source blocks exist in the signal path of output linear analysis points in your model. To do so, use the Model Advisor check Simulink Control Design Checks. For more information about using the Model Advisor, see Check Your Model Using the Model Advisor.

Version History

Introduced in R2010b