Package: frest
Identify timevarying source blocks
blocks = frest.findSources(model)
blocks = frest.findSources(model,io)
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
.

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 

Block paths of timevarying source blocks in If you provide If you do not provide 
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*')
Use frest.findSources
to identify
timevarying 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
.
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.
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.
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 (Simulink).