frest.findSources
Package: frest
Identify timevarying source blocks
Syntax
blocks = frest.findSources(model)
blocks = frest.findSources(model,io)
Description
finds
all timevarying source blocks in the signal path of any linearization
output point marked in the Simulink^{®} model blocks
= frest.findSources(model
)model
.
finds
all timevarying source blocks in the signal path of any linearization
output point specified in the array of linear analysis points blocks
= frest.findSources(model
,io
)io
.
Input Arguments

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

Array of linearization I/O points. The elements of 
Output Arguments

Block paths of timevarying source blocks in If you provide If you do not provide 
Examples
Estimate the frequency response of a model having timevarying
source blocks. This example shows the use of frest.findSources
to
identify timevarying source blocks that interfere with frequency
response estimation. You can also see the use of BlocksToHoldConstant
option
of frestimateOptions
to disable timevarying
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 timevarying source blocks on frequency response estimation. To do so, perform the estimation without disabling timevarying 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 timevarying source blocks in the model prevent the response from reaching steady state.
Find the timevarying blocks using frest.findSources
.
srcblks = frest.findSources(mdl);
srcblks
is an array of block paths corresponding
to the timevarying 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 timevarying 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 timevarying source blocks that can interfere with frequency response estimation. To disable such blocks to estimate frequency response, set theBlocksToHoldConstant
option offrestimateOptions
equal toblocks
or a subset ofblocks
. Then, estimate the frequency response usingfrestimate
.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 thatfrest.findSources
locates them. Use theset_param
command to setSimulationMode
of any referenced models toNormal
before runningfrest.FindSources
.
Algorithms
To locate timevarying 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 normalmode 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 timevarying 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 timevarying 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 timevarying 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 timevarying 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.